From 222f732449529ed5e2f39b93f9d6feb65bb79f6d Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Fri, 21 Sep 2018 14:54:43 +0400
Subject: [PATCH 01/27] Introduce SegmentId class

---
 .idea/inspectionProfiles/Druid.xml            |   9 +-
 .../org/apache/druid/data/input/Rows.java     |   7 +-
 .../segment/loading/DataSegmentFinder.java    |   9 +-
 .../apache/druid/timeline/DataSegment.java    |  99 ++---
 .../druid/timeline/DataSegmentUtils.java      | 205 ---------
 .../org/apache/druid/timeline/SegmentId.java  | 391 ++++++++++++++++++
 .../druid/timeline/DataSegmentTest.java       |   8 +-
 .../druid/timeline/DataSegmentUtilsTest.java  | 123 ------
 .../apache/druid/timeline/SegmentIdTest.java  | 179 ++++++++
 .../FilteredAggregatorBenchmark.java          |  11 +-
 .../GroupByTypeInterfaceBenchmark.java        | 101 ++---
 .../druid/benchmark/LoadStatusBenchmark.java  |  11 +-
 .../benchmark/TopNTypeInterfaceBenchmark.java |  87 ++--
 .../benchmark/datagen/SegmentGenerator.java   |  13 +-
 .../benchmark/query/GroupByBenchmark.java     |  13 +-
 .../benchmark/query/QueryBenchmarkUtil.java   |  10 +-
 .../benchmark/query/SearchBenchmark.java      |  13 +-
 .../benchmark/query/SelectBenchmark.java      |  14 +-
 .../benchmark/query/TimeseriesBenchmark.java  |  19 +-
 .../druid/benchmark/query/TopNBenchmark.java  |  15 +-
 .../timecompare/TimeCompareBenchmark.java     |  13 +-
 .../storage/azure/AzureDataSegmentKiller.java |   6 +-
 .../CloudFilesDataSegmentPusher.java          |   2 +-
 .../google/GoogleDataSegmentFinder.java       |   2 +-
 .../google/GoogleDataSegmentKiller.java       |   2 +-
 .../MaterializedViewSupervisor.java           |   4 +-
 .../druid/segment/MapVirtualColumnTest.java   |   9 +-
 .../storage/hdfs/HdfsDataSegmentFinder.java   |   5 +-
 .../storage/hdfs/HdfsDataSegmentKiller.java   |   2 +-
 .../storage/hdfs/HdfsDataSegmentPusher.java   |   2 +-
 .../loading/HdfsDataSegmentFinderTest.java    |  12 +-
 ...ementalPublishingKafkaIndexTaskRunner.java |  22 +-
 .../kafka/LegacyKafkaIndexTaskRunner.java     |  19 +-
 .../druid/storage/s3/S3DataSegmentFinder.java |   5 +-
 .../druid/storage/s3/S3DataSegmentKiller.java |   2 +-
 .../druid/storage/s3/S3DataSegmentMover.java  |   2 +-
 .../druid/storage/s3/S3DataSegmentPusher.java |   2 +-
 .../storage/s3/S3DataSegmentFinderTest.java   |  12 +-
 .../indexer/HadoopDruidIndexerConfig.java     |   3 +-
 .../druid/indexer/IndexGeneratorJob.java      |   2 +-
 .../indexer/hadoop/DatasourceInputFormat.java |   2 +-
 .../hadoop/DatasourceRecordReader.java        |   2 +-
 .../updater/HadoopConverterJobTest.java       |   4 +-
 .../ActionBasedSegmentAllocator.java          |   4 +-
 .../ActionBasedUsedSegmentChecker.java        |  16 +-
 .../SegmentAllocateActionGenerator.java       |   8 +-
 .../common/actions/SegmentAllocateAction.java |  26 +-
 .../common/index/YeOldePlumberSchool.java     |   8 +-
 .../indexing/common/task/AppendTask.java      |   2 +-
 .../indexing/common/task/ArchiveTask.java     |   4 +-
 .../indexing/common/task/CompactionTask.java  |   8 +-
 .../common/task/ConvertSegmentTask.java       |   4 +-
 .../druid/indexing/common/task/IndexTask.java |  20 +-
 .../druid/indexing/common/task/KillTask.java  |   4 +-
 .../indexing/common/task/MergeTaskBase.java   |  47 +--
 .../druid/indexing/common/task/MoveTask.java  |   4 +-
 .../indexing/common/task/RestoreTask.java     |   4 +-
 .../parallel/ParallelIndexSupervisorTask.java |  10 +-
 .../parallel/ParallelIndexTaskClient.java     |   6 +-
 .../SinglePhaseParallelIndexTaskRunner.java   |   6 +-
 .../IngestSegmentFirehoseFactory.java         |   2 +-
 .../indexing/overlord/hrtr/WorkerHolder.java  |   3 +-
 .../ActionBasedUsedSegmentCheckerTest.java    |   8 +-
 .../actions/SegmentAllocateActionTest.java    | 116 +++---
 .../actions/SegmentListActionsTest.java       |   4 +-
 .../indexing/common/task/IndexTaskTest.java   |   4 +-
 ...stractParallelIndexSupervisorTaskTest.java |   4 +-
 ...estSegmentFirehoseFactoryTimelineTest.java |   7 +-
 ...TestIndexerMetadataStorageCoordinator.java |   4 +-
 .../druid/java/util/common/DateTimes.java     |  11 +
 .../java/util/common/guava/Sequence.java      |   4 +-
 .../druid/java/util/common/DateTimesTest.java |  41 ++
 .../druid/query/BySegmentQueryRunner.java     |  17 +-
 .../query/BySegmentResultValueClass.java      |   9 +
 .../query/FinalizeResultsQueryRunner.java     |   2 +-
 .../java/org/apache/druid/query/Result.java   |   5 +-
 .../SegmentMetadataQueryRunnerFactory.java    |   2 +-
 .../metadata/metadata/SegmentAnalysis.java    |   8 +
 .../druid/query/scan/ScanQueryEngine.java     |   5 +-
 .../druid/query/scan/ScanResultValue.java     |   8 +
 .../druid/query/select/SelectQueryEngine.java |  11 +-
 .../select/SelectQueryQueryToolChest.java     |  60 ++-
 .../druid/query/topn/TopNResultValue.java     |   4 +-
 .../segment/IncrementalIndexSegment.java      |  14 +-
 .../druid/segment/QueryableIndexSegment.java  |  13 +-
 .../segment/ReferenceCountingSegment.java     |   7 +-
 .../org/apache/druid/segment/Segment.java     |   6 +-
 .../MMappedQueryableSegmentizerFactory.java   |   2 +-
 .../collections/bitmap/BitmapBenchmark.java   |   6 +-
 .../apache/druid/query/DoubleStorageTest.java |   9 +-
 .../druid/query/MultiValuedDimensionTest.java |  15 +-
 .../druid/query/QueryRunnerTestHelper.java    |  20 +-
 .../druid/query/SchemaEvolutionTest.java      |  11 +-
 .../aggregation/AggregationTestHelper.java    |   3 +-
 .../DataSourceMetadataQueryTest.java          |   7 +-
 ...ByLimitPushDownInsufficientBufferTest.java |  18 +-
 ...roupByLimitPushDownMultiNodeMergeTest.java |  14 +-
 .../groupby/GroupByMultiSegmentTest.java      |   7 +-
 .../GroupByQueryRunnerFactoryTest.java        |   3 +-
 .../query/metadata/SegmentAnalyzerTest.java   |   5 +-
 .../metadata/SegmentMetadataQueryTest.java    |  15 +-
 .../SegmentMetadataUnionQueryTest.java        |  18 +-
 .../query/scan/MultiSegmentScanQueryTest.java |  18 +-
 .../druid/query/scan/ScanQueryRunnerTest.java |   8 +-
 .../query/search/SearchQueryRunnerTest.java   |   5 +-
 .../search/SearchQueryRunnerWithCaseTest.java |  17 +-
 .../select/MultiSegmentSelectQueryTest.java   |  29 +-
 .../query/select/SelectQueryRunnerTest.java   |  79 ++--
 .../TimeBoundaryQueryRunnerTest.java          |  25 +-
 .../TimeseriesQueryRunnerBonusTest.java       |  16 +-
 .../topn/TopNQueryQueryToolChestTest.java     |   3 +-
 .../query/topn/TopNQueryRunnerBenchmark.java  |   7 +-
 .../druid/query/topn/TopNQueryRunnerTest.java |  15 +-
 .../org/apache/druid/segment/AppendTest.java  |  19 +-
 .../IndexMergerV9WithSpatialIndexTest.java    |   8 +-
 .../segment/ReferenceCountingSegmentTest.java |   5 +-
 .../druid/segment/SchemalessTestFullTest.java |  14 +-
 .../segment/SchemalessTestSimpleTest.java     |   4 +-
 .../filter/SpatialFilterBonusTest.java        |   4 +-
 .../segment/filter/SpatialFilterTest.java     |   4 +-
 .../AbstractCuratorServerInventoryView.java   |  65 +--
 .../client/BatchServerInventoryView.java      |   4 +-
 .../apache/druid/client/BrokerServerView.java |  12 +-
 .../org/apache/druid/client/CacheUtil.java    |   4 +-
 .../druid/client/CachingClusteredClient.java  |  18 +-
 .../druid/client/CachingQueryRunner.java      |   8 +-
 .../druid/client/CoordinatorServerView.java   |  14 +-
 .../apache/druid/client/DruidDataSource.java  |  59 ++-
 .../org/apache/druid/client/DruidServer.java  | 215 +++++-----
 .../druid/client/HttpServerInventoryView.java |  27 +-
 .../client/ImmutableDruidDataSource.java      |  48 ++-
 .../druid/client/ImmutableDruidServer.java    |  40 +-
 .../apache/druid/client/InventoryView.java    |   4 +-
 .../inventory/CuratorInventoryManager.java    |  24 +-
 .../CuratorInventoryManagerStrategy.java      |   4 +
 .../druid/discovery/DiscoveryDruidNode.java   |  14 +
 .../SQLMetadataStorageUpdaterJobHandler.java  |   4 +-
 .../IndexerMetadataStorageCoordinator.java    |   4 +-
 .../IndexerSQLMetadataStorageCoordinator.java | 146 +++----
 .../metadata/MetadataSegmentManager.java      |  27 +-
 .../metadata/SQLMetadataRuleManager.java      |   2 +-
 .../metadata/SQLMetadataSegmentManager.java   | 348 ++++++++--------
 .../metadata/SQLMetadataSegmentPublisher.java |  10 +-
 .../query/lookup/LookupReferencesManager.java |   3 +-
 .../loading/LocalDataSegmentFinder.java       |   9 +-
 .../loading/LocalDataSegmentKiller.java       |   2 +-
 .../loading/LocalDataSegmentPusher.java       |   4 +-
 .../SegmentLoaderLocalCacheManager.java       |   4 +-
 .../segment/loading/StorageLocation.java      |   4 +-
 .../druid/segment/realtime/FireHydrant.java   |  19 +-
 .../realtime/appenderator/Appenderator.java   |  24 +-
 .../AppenderatorDriverAddResult.java          |   8 +-
 .../AppenderatorDriverMetadata.java           |   4 +-
 .../appenderator/AppenderatorImpl.java        |  85 ++--
 .../appenderator/AppenderatorPlumber.java     |  35 +-
 .../appenderator/BaseAppenderatorDriver.java  |  33 +-
 .../appenderator/BatchAppenderatorDriver.java |   6 +-
 .../realtime/appenderator/Committed.java      |   6 +-
 .../appenderator/SegmentAllocator.java        |   2 +-
 ...ifier.java => SegmentIdWithShardSpec.java} |  61 ++-
 .../appenderator/SegmentWithState.java        |  13 +-
 .../appenderator/SinkQuerySegmentWalker.java  |  18 +-
 .../StreamAppenderatorDriver.java             |  23 +-
 .../appenderator/UsedSegmentChecker.java      |   2 +-
 .../realtime/plumber/FlushingPlumber.java     |   4 +-
 .../realtime/plumber/RealtimePlumber.java     |  40 +-
 .../druid/segment/realtime/plumber/Sink.java  |  15 +-
 .../druid/server/ClientInfoResource.java      |  72 ++--
 .../apache/druid/server/SegmentManager.java   |   4 +-
 .../BatchDataSegmentAnnouncer.java            |  14 +-
 .../coordination/ChangeRequestHistory.java    |  55 +--
 .../coordination/ChangeRequestHttpSyncer.java | 112 ++---
 .../coordination/ChangeRequestsSnapshot.java  |  33 +-
 .../coordination/DruidServerMetadata.java     |   5 +-
 .../SegmentChangeRequestDrop.java             |   2 +-
 .../SegmentChangeRequestLoad.java             |   2 +-
 .../coordination/SegmentLoadDropHandler.java  |  24 +-
 .../server/coordination/ServerManager.java    |  22 +-
 .../server/coordination/package-info.java     |  23 ++
 .../coordinator/CostBalancerStrategy.java     |  12 +-
 .../coordinator/CuratorLoadQueuePeon.java     |  34 +-
 .../server/coordinator/DruidCoordinator.java  |  61 ++-
 .../server/coordinator/HttpLoadQueuePeon.java |  12 +-
 .../coordinator/ReplicationThrottler.java     |  57 ++-
 .../coordinator/ReservoirSegmentSampler.java  |   2 +-
 .../coordinator/SegmentReplicantLookup.java   |  39 +-
 .../server/coordinator/ServerHolder.java      |  10 +-
 .../helper/DruidCoordinatorBalancer.java      |  23 +-
 .../DruidCoordinatorCleanupUnneeded.java      |   2 +-
 .../helper/DruidCoordinatorLogger.java        |  10 +-
 .../helper/DruidCoordinatorRuleRunner.java    |   5 +-
 .../helper/DruidCoordinatorSegmentKiller.java |   2 +-
 .../helper/DruidCoordinatorSegmentMerger.java |  22 +-
 .../DruidCoordinatorVersionConverter.java     |   2 +-
 .../rules/BroadcastDistributionRule.java      |   2 +-
 .../server/coordinator/rules/LoadRule.java    |  27 +-
 .../server/http/CoordinatorResource.java      |  34 +-
 ...Resource.java => DataSourcesResource.java} | 208 ++++------
 .../druid/server/http/InventoryViewUtils.java |   7 +-
 .../druid/server/http/MetadataResource.java   |  32 +-
 .../druid/server/http/ServersResource.java    | 165 ++++----
 .../druid/server/http/TiersResource.java      | 108 ++---
 .../partition/HashBasedNumberedShardSpec.java |   7 +-
 .../timeline/partition/LinearShardSpec.java   |  29 +-
 .../client/CachingClusteredClientTest.java    | 123 +++---
 .../druid/client/CachingQueryRunnerTest.java  |  12 +-
 .../client/CoordinatorServerViewTest.java     |  10 +-
 .../client/HttpServerInventoryViewTest.java   |  40 +-
 .../client/ImmutableDruidDataSourceTest.java  |   2 +-
 .../client/BatchServerInventoryViewTest.java  |  21 +-
 .../apache/druid/curator/CuratorTestBase.java |  20 +-
 ...exerSQLMetadataStorageCoordinatorTest.java |  68 +--
 .../SQLMetadataSegmentManagerTest.java        |  16 +-
 .../loading/CacheTestSegmentLoader.java       |   5 +-
 .../loading/LocalDataSegmentFinderTest.java   |  10 +-
 .../appenderator/AppenderatorPlumberTest.java |   2 +-
 .../appenderator/AppenderatorTest.java        |  20 +-
 .../BatchAppenderatorDriverTest.java          |  14 +-
 .../realtime/appenderator/CommittedTest.java  |  12 +-
 ...DefaultOfflineAppenderatorFactoryTest.java |   2 +-
 ...t.java => SegmentIdWithShardSpecTest.java} |  14 +-
 .../StreamAppenderatorDriverFailTest.java     |  14 +-
 .../StreamAppenderatorDriverTest.java         |  20 +-
 .../appenderator/TestUsedSegmentChecker.java  |   6 +-
 .../druid/server/SegmentManagerTest.java      |  10 +-
 .../SegmentChangeRequestDropTest.java         |   3 +-
 .../SegmentLoadDropHandlerTest.java           |  42 +-
 .../coordination/ServerManagerTest.java       |   5 +-
 .../coordination/ZkCoordinatorTest.java       |   6 +-
 .../coordinator/CostBalancerStrategyTest.java |  47 ++-
 .../CuratorDruidCoordinatorTest.java          |  19 +-
 ...iskNormalizedCostBalancerStrategyTest.java |  27 +-
 .../server/coordinator/DruidClusterTest.java  |  55 +--
 .../DruidCoordinatorBalancerProfiler.java     |  20 +-
 .../DruidCoordinatorBalancerTest.java         |  37 +-
 .../DruidCoordinatorBalancerTester.java       |  19 +-
 .../coordinator/DruidCoordinatorTest.java     |  27 +-
 .../coordinator/HttpLoadQueuePeonTest.java    |  53 +--
 .../server/coordinator/LoadQueuePeonTest.java |  15 +-
 .../ReservoirSegmentSamplerTest.java          |  40 +-
 .../server/coordinator/ServerHolderTest.java  | 105 +----
 .../cost/CachingCostBalancerStrategyTest.java |   4 +-
 .../coordinator/rules/LoadRuleTest.java       |   2 +-
 ...Test.java => DataSourcesResourceTest.java} | 107 ++---
 .../server/http/IntervalsResourceTest.java    |   6 +-
 .../security/SecurityResourceFilterTest.java  |   4 +-
 .../druid/timeline/DataSegmentTest.java       |  14 +-
 .../org/apache/druid/cli/CliCoordinator.java  |   6 +-
 .../apache/druid/cli/CliRealtimeExample.java  |   2 +-
 .../org/apache/druid/cli/DumpSegment.java     |  12 +-
 .../org/apache/druid/cli/InsertSegment.java   |   4 +-
 .../sql/calcite/planner/DruidPlanner.java     |   4 +-
 .../sql/calcite/rel/DruidOuterQueryRel.java   |   4 +-
 .../druid/sql/calcite/rel/DruidQueryRel.java  |   2 +-
 .../druid/sql/calcite/rel/DruidRel.java       |   2 +-
 .../druid/sql/calcite/rel/DruidSemiJoin.java  |   6 +-
 .../druid/sql/calcite/rel/DruidUnionRel.java  |   4 +-
 .../druid/sql/calcite/schema/DruidSchema.java |  30 +-
 .../SpecificSegmentsQuerySegmentWalker.java   |   4 +-
 259 files changed, 3226 insertions(+), 3223 deletions(-)
 delete mode 100644 api/src/main/java/org/apache/druid/timeline/DataSegmentUtils.java
 create mode 100644 api/src/main/java/org/apache/druid/timeline/SegmentId.java
 delete mode 100644 api/src/test/java/org/apache/druid/timeline/DataSegmentUtilsTest.java
 create mode 100644 api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
 create mode 100644 java-util/src/test/java/org/apache/druid/java/util/common/DateTimesTest.java
 rename server/src/main/java/org/apache/druid/segment/realtime/appenderator/{SegmentIdentifier.java => SegmentIdWithShardSpec.java} (68%)
 create mode 100644 server/src/main/java/org/apache/druid/server/coordination/package-info.java
 rename server/src/main/java/org/apache/druid/server/http/{DatasourcesResource.java => DataSourcesResource.java} (77%)
 rename server/src/test/java/org/apache/druid/segment/realtime/appenderator/{SegmentIdentifierTest.java => SegmentIdWithShardSpecTest.java} (83%)
 rename server/src/test/java/org/apache/druid/server/http/{DatasourcesResourceTest.java => DataSourcesResourceTest.java} (88%)

diff --git a/.idea/inspectionProfiles/Druid.xml b/.idea/inspectionProfiles/Druid.xml
index 38d6033a81a1..6d6fd3ea4a5b 100644
--- a/.idea/inspectionProfiles/Druid.xml
+++ b/.idea/inspectionProfiles/Druid.xml
@@ -63,7 +63,6 @@
     <inspection_tool class="InvalidComparatorMethodReference" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="IteratorHasNextCallsIteratorNext" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="IteratorNextDoesNotThrowNoSuchElementException" enabled="true" level="WARNING" enabled_by_default="true" />
-    <inspection_tool class="JavadocReference" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="JsonStandardCompliance" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="MalformedFormatString" enabled="true" level="ERROR" enabled_by_default="true">
       <option name="additionalClasses" value="org.apache.druid.java.util.common.StringUtils,org.apache.druid.java.util.common.logger.Logger" />
@@ -113,7 +112,7 @@
       <searchConfiguration name="Suboptimal IndexedInts iteration" text="$x$ &lt; $y$.size()" recursive="false" caseInsensitive="true" type="JAVA">
         <constraint name="__context__" target="true" within="" contains="" />
         <constraint name="x" within="" contains="" />
-        <constraint name="y" nameOfExprType="IndexedInts" exprTypeWithinHierarchy="true" within="" contains="" />
+        <constraint name="y" nameOfExprType="IndexedInts" expressionTypes="IndexedInts" exprTypeWithinHierarchy="true" within="" contains="" />
       </searchConfiguration>
       <searchConfiguration name="Lists.newArrayList() with a single argument. Use Collections.singletonList() instead" created="1532737126203" text="Lists.newArrayList($x$)" recursive="false" caseInsensitive="true" type="JAVA">
         <constraint name="x" nameOfExprType="java\.lang\.Iterable|java\.util\.Iterator|Object\[\]" expressionTypes="java.lang.Iterable|java.util.Iterator|Object[]" exprTypeWithinHierarchy="true" negateName="true" negateExprType="true" within="" contains="" />
@@ -134,6 +133,12 @@
         <constraint name="x" nameOfFormalType="java\.util\.Random" exceptedTypes="java.util.Random" exprTypeWithinHierarchy="true" formalTypeWithinHierarchy="true" within="" contains="" />
         <constraint name="a" within="" contains="" />
       </searchConfiguration>
+      <searchConfiguration name="Use ZKPaths.makePath() with many arguments" created="1537504371779" text="org.apache.curator.utils.ZKPaths.makePath(org.apache.curator.utils.ZKPaths.makePath($x$, $y$), $z$)" recursive="false" caseInsensitive="true" type="JAVA">
+        <constraint name="__context__" target="true" within="" contains="" />
+        <constraint name="x" within="" contains="" />
+        <constraint name="y" within="" contains="" />
+        <constraint name="z" within="" contains="" />
+      </searchConfiguration>
     </inspection_tool>
     <inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
       <option name="processCode" value="true" />
diff --git a/api/src/main/java/org/apache/druid/data/input/Rows.java b/api/src/main/java/org/apache/druid/data/input/Rows.java
index a1aedfff75cf..6c31f6d552d1 100644
--- a/api/src/main/java/org/apache/druid/data/input/Rows.java
+++ b/api/src/main/java/org/apache/druid/data/input/Rows.java
@@ -38,8 +38,6 @@
  */
 public class Rows
 {
-  public static final Long LONG_ZERO = 0L;
-
   /**
    * @param timeStamp rollup up timestamp to be used to create group key
    * @param inputRow  input row
@@ -55,10 +53,7 @@ public static List<Object> toGroupKey(long timeStamp, InputRow inputRow)
         dims.put(dim, dimValues);
       }
     }
-    return ImmutableList.of(
-        timeStamp,
-        dims
-    );
+    return ImmutableList.of(timeStamp, dims);
   }
 
   /**
diff --git a/api/src/main/java/org/apache/druid/segment/loading/DataSegmentFinder.java b/api/src/main/java/org/apache/druid/segment/loading/DataSegmentFinder.java
index ce4ce3a3b5fc..5d28706367b2 100644
--- a/api/src/main/java/org/apache/druid/segment/loading/DataSegmentFinder.java
+++ b/api/src/main/java/org/apache/druid/segment/loading/DataSegmentFinder.java
@@ -23,6 +23,7 @@
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 import java.util.Map;
 import java.util.Set;
@@ -61,14 +62,16 @@ public interface DataSegmentFinder
    * @param segmentModifiedAt   segment modified timestamp
    */
   static void putInMapRetainingNewest(
-      Map<String, Pair<DataSegment, Long>> timestampedSegments, DataSegment dataSegment, long segmentModifiedAt
+      Map<SegmentId, Pair<DataSegment, Long>> timestampedSegments,
+      DataSegment dataSegment,
+      long segmentModifiedAt
   )
   {
     timestampedSegments.merge(
-        dataSegment.getIdentifier(),
+        dataSegment.getId(),
         Pair.of(dataSegment, segmentModifiedAt),
         (previous, current) -> {
-          log.warn("Multiple copies of segmentId [%s] found, using newest version", current.lhs.getIdentifier());
+          log.warn("Multiple copies of segmentId [%s] found, using newest version", current.lhs.getId());
           return previous.rhs > current.rhs ? previous : current;
         }
     );
diff --git a/api/src/main/java/org/apache/druid/timeline/DataSegment.java b/api/src/main/java/org/apache/druid/timeline/DataSegment.java
index b1b8c33a2735..080b7e576bd8 100644
--- a/api/src/main/java/org/apache/druid/timeline/DataSegment.java
+++ b/api/src/main/java/org/apache/druid/timeline/DataSegment.java
@@ -50,41 +50,20 @@
 import java.util.stream.Collectors;
 
 /**
+ * Metadata of Druid's data segment. An immutable object.
+ *
+ * DataSegment's equality ({@link #equals}/{@link #hashCode}) and {@link #compareTo} methods consider only the
+ * {@link SegmentId} of the segment.
  */
 @PublicApi
 public class DataSegment implements Comparable<DataSegment>
 {
-  public static String delimiter = "_";
-  private final Integer binaryVersion;
-  private static final Interner<String> STRING_INTERNER = Interners.newWeakInterner();
-  private static final Interner<List<String>> DIMENSIONS_INTERNER = Interners.newWeakInterner();
-  private static final Interner<List<String>> METRICS_INTERNER = Interners.newWeakInterner();
-  private static final Map<String, Object> PRUNED_LOAD_SPEC = ImmutableMap.of(
-      "load spec is pruned, because it's not needed on Brokers, but eats a lot of heap space",
-      ""
-  );
-
-  public static String makeDataSegmentIdentifier(
-      String dataSource,
-      DateTime start,
-      DateTime end,
-      String version,
-      ShardSpec shardSpec
-  )
-  {
-    StringBuilder sb = new StringBuilder();
-
-    sb.append(dataSource).append(delimiter)
-      .append(start).append(delimiter)
-      .append(end).append(delimiter)
-      .append(version);
-
-    if (shardSpec.getPartitionNum() != 0) {
-      sb.append(delimiter).append(shardSpec.getPartitionNum());
-    }
-
-    return sb.toString();
-  }
+  /*
+   * The difference between this class and org.apache.druid.segment.Segment is that this class contains the segment
+   * metadata only, while org.apache.druid.segment.Segment represents the actual body of segment data, queryable.
+   *
+   * TODO explain the difference with org.apache.druid.query.SegmentDescriptor
+   */
 
   /**
    * This class is needed for optional injection of pruneLoadSpec, see
@@ -99,16 +78,22 @@ public static class PruneLoadSpecHolder
     @Inject(optional = true) @PruneLoadSpec boolean pruneLoadSpec = false;
   }
 
-  private final String dataSource;
-  private final Interval interval;
-  private final String version;
+  private static final Interner<String> STRING_INTERNER = Interners.newWeakInterner();
+  private static final Interner<List<String>> DIMENSIONS_INTERNER = Interners.newWeakInterner();
+  private static final Interner<List<String>> METRICS_INTERNER = Interners.newWeakInterner();
+  private static final Map<String, Object> PRUNED_LOAD_SPEC = ImmutableMap.of(
+      "load spec is pruned, because it's not needed on Brokers, but eats a lot of heap space",
+      ""
+  );
+
+  private final Integer binaryVersion;
+  private final SegmentId id;
   @Nullable
   private final Map<String, Object> loadSpec;
   private final List<String> dimensions;
   private final List<String> metrics;
   private final ShardSpec shardSpec;
   private final long size;
-  private final String identifier;
 
   public DataSegment(
       String dataSource,
@@ -157,12 +142,8 @@ public DataSegment(
       @JacksonInject PruneLoadSpecHolder pruneLoadSpecHolder
   )
   {
-    // dataSource, dimensions & metrics are stored as canonical string values to decrease memory required for storing
-    // large numbers of segments.
-    this.dataSource = STRING_INTERNER.intern(dataSource);
-    this.interval = interval;
+    this.id = SegmentId.of(dataSource, interval, version, shardSpec);
     this.loadSpec = pruneLoadSpecHolder.pruneLoadSpec ? PRUNED_LOAD_SPEC : prepareLoadSpec(loadSpec);
-    this.version = version;
     // Deduplicating dimensions and metrics lists as a whole because they are very likely the same for the same
     // dataSource
     this.dimensions = prepareDimensionsOrMetrics(dimensions, DIMENSIONS_INTERNER);
@@ -170,14 +151,6 @@ public DataSegment(
     this.shardSpec = (shardSpec == null) ? NoneShardSpec.instance() : shardSpec;
     this.binaryVersion = binaryVersion;
     this.size = size;
-
-    this.identifier = makeDataSegmentIdentifier(
-        this.dataSource,
-        this.interval.getStart(),
-        this.interval.getEnd(),
-        this.version,
-        this.shardSpec
-    );
   }
 
   @Nullable
@@ -202,6 +175,8 @@ private List<String> prepareDimensionsOrMetrics(@Nullable List<String> list, Int
       List<String> result = list
           .stream()
           .filter(s -> !Strings.isNullOrEmpty(s))
+          // dimensions & metrics are stored as canonical string values to decrease memory required for storing
+          // large numbers of segments.
           .map(STRING_INTERNER::intern)
           // TODO replace with ImmutableList.toImmutableList() when updated to Guava 21+
           .collect(Collectors.collectingAndThen(Collectors.toList(), ImmutableList::copyOf));
@@ -217,13 +192,13 @@ private List<String> prepareDimensionsOrMetrics(@Nullable List<String> list, Int
   @JsonProperty
   public String getDataSource()
   {
-    return dataSource;
+    return id.getDataSource();
   }
 
   @JsonProperty
   public Interval getInterval()
   {
-    return interval;
+    return id.getInterval();
   }
 
   @Nullable
@@ -236,7 +211,7 @@ public Map<String, Object> getLoadSpec()
   @JsonProperty
   public String getVersion()
   {
-    return version;
+    return id.getVersion();
   }
 
   @JsonProperty
@@ -271,15 +246,15 @@ public long getSize()
     return size;
   }
 
-  @JsonProperty
-  public String getIdentifier()
+  @JsonProperty("identifier") // matching the established public HTTP JSON API
+  public SegmentId getId()
   {
-    return identifier;
+    return id;
   }
 
   public SegmentDescriptor toDescriptor()
   {
-    return new SegmentDescriptor(interval, version, shardSpec.getPartitionNum());
+    return new SegmentDescriptor(getInterval(), getVersion(), shardSpec.getPartitionNum());
   }
 
   public DataSegment withLoadSpec(Map<String, Object> loadSpec)
@@ -315,14 +290,14 @@ public DataSegment withBinaryVersion(int binaryVersion)
   @Override
   public int compareTo(DataSegment dataSegment)
   {
-    return getIdentifier().compareTo(dataSegment.getIdentifier());
+    return getId().compareTo(dataSegment.getId());
   }
 
   @Override
   public boolean equals(Object o)
   {
     if (o instanceof DataSegment) {
-      return getIdentifier().equals(((DataSegment) o).getIdentifier());
+      return getId().equals(((DataSegment) o).getId());
     }
     return false;
   }
@@ -330,7 +305,7 @@ public boolean equals(Object o)
   @Override
   public int hashCode()
   {
-    return getIdentifier().hashCode();
+    return getId().hashCode();
   }
 
   @Override
@@ -341,10 +316,10 @@ public String toString()
            ", shardSpec=" + shardSpec +
            ", metrics=" + metrics +
            ", dimensions=" + dimensions +
-           ", version='" + version + '\'' +
+           ", version='" + getVersion() + '\'' +
            ", loadSpec=" + loadSpec +
-           ", interval=" + interval +
-           ", dataSource='" + dataSource + '\'' +
+           ", interval=" + getInterval() +
+           ", dataSource='" + getDataSource() + '\'' +
            ", binaryVersion='" + binaryVersion + '\'' +
            '}';
   }
@@ -472,7 +447,7 @@ public Builder size(long size)
 
     public DataSegment build()
     {
-      // Check stuff that goes into the identifier, at least.
+      // Check stuff that goes into the id, at least.
       Preconditions.checkNotNull(dataSource, "dataSource");
       Preconditions.checkNotNull(interval, "interval");
       Preconditions.checkNotNull(version, "version");
diff --git a/api/src/main/java/org/apache/druid/timeline/DataSegmentUtils.java b/api/src/main/java/org/apache/druid/timeline/DataSegmentUtils.java
deleted file mode 100644
index 6edd2101289c..000000000000
--- a/api/src/main/java/org/apache/druid/timeline/DataSegmentUtils.java
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.timeline;
-
-import com.google.common.base.Function;
-import org.apache.druid.guice.annotations.PublicApi;
-import org.apache.druid.java.util.common.DateTimes;
-import org.apache.druid.java.util.common.IAE;
-import org.apache.druid.java.util.common.StringUtils;
-import org.apache.druid.java.util.common.logger.Logger;
-import org.joda.time.DateTime;
-import org.joda.time.Interval;
-
-import java.util.Objects;
-
-@PublicApi
-public class DataSegmentUtils
-{
-  private static final Logger LOGGER = new Logger(DataSegmentUtils.class);
-
-  public static Function<String, Interval> INTERVAL_EXTRACTOR(final String datasource)
-  {
-    return new Function<String, Interval>()
-    {
-      @Override
-      public Interval apply(String identifier)
-      {
-        SegmentIdentifierParts segmentIdentifierParts = valueOf(datasource, identifier);
-        if (segmentIdentifierParts == null) {
-          throw new IAE("Invalid identifier [%s]", identifier);
-        }
-
-        return segmentIdentifierParts.getInterval();
-      }
-    };
-  }
-
-  /**
-   * Parses a segment identifier into its components: dataSource, interval, version, and any trailing tags. Ignores
-   * shard spec.
-   *
-   * It is possible that this method may incorrectly parse an identifier, for example if the dataSource name in the
-   * identifier contains a DateTime parseable string such as 'datasource_2000-01-01T00:00:00.000Z' and dataSource was
-   * provided as 'datasource'. The desired behavior in this case would be to return null since the identifier does not
-   * actually belong to the provided dataSource but a non-null result would be returned. This is an edge case that would
-   * currently only affect paged select queries with a union dataSource of two similarly-named dataSources as in the
-   * given example.
-   *
-   * @param dataSource the dataSource corresponding to this identifier
-   * @param identifier segment identifier
-   * @return a {@link DataSegmentUtils.SegmentIdentifierParts} object if the identifier could be parsed, null otherwise
-   */
-  public static SegmentIdentifierParts valueOf(String dataSource, String identifier)
-  {
-    if (!identifier.startsWith(StringUtils.format("%s_", dataSource))) {
-      return null;
-    }
-
-    String remaining = identifier.substring(dataSource.length() + 1);
-    String[] splits = remaining.split(DataSegment.delimiter);
-    if (splits.length < 3) {
-      return null;
-    }
-
-    try {
-      DateTime start = DateTimes.ISO_DATE_TIME.parse(splits[0]);
-      DateTime end = DateTimes.ISO_DATE_TIME.parse(splits[1]);
-      String version = splits[2];
-      String trail = splits.length > 3 ? join(splits, DataSegment.delimiter, 3, splits.length) : null;
-
-      return new SegmentIdentifierParts(
-          dataSource,
-          new Interval(start, end),
-          version,
-          trail
-      );
-    }
-    catch (IllegalArgumentException e) {
-      return null;
-    }
-  }
-
-  public static String withInterval(final String dataSource, final String identifier, Interval newInterval)
-  {
-    SegmentIdentifierParts segmentDesc = DataSegmentUtils.valueOf(dataSource, identifier);
-    if (segmentDesc == null) {
-      // happens for test segments which has invalid segment id.. ignore for now
-      LOGGER.warn("Invalid segment identifier " + identifier);
-      return identifier;
-    }
-    return segmentDesc.withInterval(newInterval).toString();
-  }
-
-  public static class SegmentIdentifierParts
-  {
-    private final String dataSource;
-    private final Interval interval;
-    private final String version;
-    private final String trail;
-
-    public SegmentIdentifierParts(String dataSource, Interval interval, String version, String trail)
-    {
-      this.dataSource = dataSource;
-      this.interval = interval;
-      this.version = version;
-      this.trail = trail;
-    }
-
-    @PublicApi
-    public String getDataSource()
-    {
-      return dataSource;
-    }
-
-    public Interval getInterval()
-    {
-      return interval;
-    }
-
-    @PublicApi
-    public String getVersion()
-    {
-      return version;
-    }
-
-    public SegmentIdentifierParts withInterval(Interval interval)
-    {
-      return new SegmentIdentifierParts(dataSource, interval, version, trail);
-    }
-
-    @Override
-    public boolean equals(Object o)
-    {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-
-      SegmentIdentifierParts that = (SegmentIdentifierParts) o;
-
-      if (!Objects.equals(dataSource, that.dataSource)) {
-        return false;
-      }
-      if (!Objects.equals(interval, that.interval)) {
-        return false;
-      }
-      if (!Objects.equals(version, that.version)) {
-        return false;
-      }
-      if (!Objects.equals(trail, that.trail)) {
-        return false;
-      }
-
-      return true;
-    }
-
-    @Override
-    public int hashCode()
-    {
-      return Objects.hash(dataSource, interval, version, trail);
-    }
-
-    @Override
-    public String toString()
-    {
-      return join(
-          new Object[]{dataSource, interval.getStart(), interval.getEnd(), version, trail},
-          DataSegment.delimiter, 0, version == null ? 3 : trail == null ? 4 : 5
-      );
-    }
-  }
-
-  private static String join(Object[] input, String delimiter, int start, int end)
-  {
-    StringBuilder builder = new StringBuilder();
-    for (int i = start; i < end; i++) {
-      if (i > start) {
-        builder.append(delimiter);
-      }
-      if (input[i] != null) {
-        builder.append(input[i]);
-      }
-    }
-    return builder.toString();
-  }
-}
diff --git a/api/src/main/java/org/apache/druid/timeline/SegmentId.java b/api/src/main/java/org/apache/druid/timeline/SegmentId.java
new file mode 100644
index 000000000000..566f813cf645
--- /dev/null
+++ b/api/src/main/java/org/apache/druid/timeline/SegmentId.java
@@ -0,0 +1,391 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.timeline;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+import com.google.common.collect.Interner;
+import com.google.common.collect.Interners;
+import com.google.common.collect.Iterables;
+import com.google.common.primitives.Ints;
+import org.apache.druid.guice.annotations.PublicApi;
+import org.apache.druid.java.util.common.DateTimes;
+import org.apache.druid.java.util.common.IAE;
+import org.apache.druid.java.util.common.Intervals;
+import org.apache.druid.timeline.partition.ShardSpec;
+import org.joda.time.Chronology;
+import org.joda.time.DateTime;
+import org.joda.time.Interval;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.stream.IntStream;
+
+/**
+ * Identifier of {@link DataSegment}.
+ */
+@PublicApi
+public final class SegmentId implements Comparable<SegmentId>
+{
+  /*
+   * Implementation note: this class must be optimized for resident memory footprint, because segment data consumes
+   * a lot of heap memory on Druid Broker and Coordinator nodes.
+   *
+   * API design note: "SegmentId" is chosen as the name for this class instead of more verbose "SegmentIdentifier" or
+   * "DataSegmentIdentifier" because it's used very frequently and a long class name adds noticeable clutter. Variables
+   * of SegmentId type are recommended to be named "segmentId" rather than "identifier" or "segmentIdentifier".
+   */
+
+  /**
+   * {@link #dataSource} and {@link #version} are stored as canonical string values to decrease memory required for
+   * storing large numbers of segment identifiers.
+   */
+  private static final Interner<String> STRING_INTERNER = Interners.newWeakInterner();
+
+  private static final char DELIMITER = '_';
+  private static final Splitter DELIMITER_SPLITTER = Splitter.on(DELIMITER);
+  private static final Joiner DELIMITER_JOINER = Joiner.on(DELIMITER);
+
+  private static final int DATE_TIME_SIZE_UPPER_LIMIT = "yyyy-MM-ddTHH:mm:ss.SSS+00:00".length();
+
+  public static SegmentId of(String dataSource, Interval interval, String version, int partitionNum)
+  {
+    return new SegmentId(dataSource, interval, version, partitionNum);
+  }
+
+  public static SegmentId of(String dataSource, Interval interval, String version, @Nullable ShardSpec shardSpec)
+  {
+    return of(dataSource, interval, version, shardSpec != null ? shardSpec.getPartitionNum() : 0);
+  }
+
+  /**
+   * Tries to parse a segment id from the given String representation, or returns null on failure. If returns a non-null
+   * {@code SegmentId} object, calling {@link #toString()} on the latter is guaranteed to return a string equal to the
+   * argument string of the {@code tryParse()} call.
+   *
+   * It is possible that this method may incorrectly parse a segment id, for example if the dataSource name in the
+   * segment id contains a DateTime parseable string such as 'datasource_2000-01-01T00:00:00.000Z' and dataSource was
+   * provided as 'datasource'. The desired behavior in this case would be to return null since the identifier does not
+   * actually belong to the provided dataSource but a non-null result would be returned. This is an edge case that would
+   * currently only affect paged select queries with a union dataSource of two similarly-named dataSources as in the
+   * given example.
+   *
+   * Another source of ambiguity is the end of a segment id like '_123' - it could always be interpreted either as the
+   * partitionNum of the segment id, or as the end of the version, with the implicit partitionNum of 0. This method
+   * prefers the first iterpretation. To iterate all possible parsings of a segment id, use {@link
+   * #iteratePossibleParsingsWithDataSource}.
+   *
+   * @param dataSource the dataSource corresponding to this segment id
+   * @param segmentId segment id
+   * @return a {@link SegmentId} object if the segment id could be parsed, null otherwise
+   */
+  @Nullable
+  public static SegmentId tryParse(String dataSource, String segmentId)
+  {
+    List<SegmentId> possibleParsings = iteratePossibleParsingsWithDataSource(dataSource, segmentId);
+    return possibleParsings.isEmpty() ? null : possibleParsings.get(0);
+  }
+
+  /**
+   * Returns a (potentially empty) lazy iteration of all possible valid parsings of the given segment id string into
+   * {@code SegmentId} objects.
+   *
+   * Warning: this iterable is repeats most of the parsing work on each iteration, so it should be iterated only once if
+   * possible.
+   */
+  public static Iterable<SegmentId> iterateAllPossibleParsings(String segmentId)
+  {
+    List<String> splits = DELIMITER_SPLITTER.splitToList(segmentId);
+    String probableDataSource = tryExtractMostProbableDataSource(segmentId);
+    // Iterate probable parsings first to allow for the users of iterateAllPossibleParsings() to break from the
+    // iteration earlier with higher probability.
+    if (probableDataSource != null) {
+      List<SegmentId> probableParsings = iteratePossibleParsingsWithDataSource(probableDataSource, segmentId);
+      Iterable<SegmentId> otherPossibleParsings = () -> IntStream
+          .range(1, splits.size() - 3)
+          .mapToObj(dataSourceDelimiterOrder -> DELIMITER_JOINER.join(splits.subList(0, dataSourceDelimiterOrder)))
+          .filter(dataSource -> dataSource.length() != probableDataSource.length())
+          .flatMap(dataSource -> iteratePossibleParsingsWithDataSource(dataSource, segmentId).stream())
+          .iterator();
+      return Iterables.concat(probableParsings, otherPossibleParsings);
+    } else {
+      return () -> IntStream
+          .range(1, splits.size() - 3)
+          .mapToObj(dataSourceDelimiterOrder -> {
+            String dataSource = DELIMITER_JOINER.join(splits.subList(0, dataSourceDelimiterOrder));
+            return iteratePossibleParsingsWithDataSource(dataSource, segmentId);
+          })
+          .flatMap(List::stream)
+          .iterator();
+    }
+  }
+
+  /**
+   * Returns a list of either 0, 1 or 2 elements containing possible parsings if the given segment id String
+   * representation with the given data source name. Returns an empty list when parsing into a valid {@code SegmentId}
+   * object is impossible. Returns a list of a single element when the given segment id doesn't end with
+   * '_[any positive number]', that means that the implicit partitionNum is 0. Otherwise the end of the segment id
+   * is interpreted in two ways: with the explicit partitionNum (the first element in the returned list), and with the
+   * implicit partitionNum of 0 and the version that ends with '_[any positive number]' (the second element in the
+   * returned list).
+   */
+  public static List<SegmentId> iteratePossibleParsingsWithDataSource(String dataSource, String segmentId)
+  {
+    if (!segmentId.startsWith(dataSource) || segmentId.charAt(dataSource.length()) != DELIMITER) {
+      return Collections.emptyList();
+    }
+
+    String remaining = segmentId.substring(dataSource.length() + 1);
+    List<String> splits = DELIMITER_SPLITTER.splitToList(remaining);
+    if (splits.size() < 3) {
+      return Collections.emptyList();
+    }
+
+    DateTime start;
+    DateTime end;
+    try {
+      start = DateTimes.ISO_DATE_TIME.parse(splits.get(0));
+      end = DateTimes.ISO_DATE_TIME.parse(splits.get(1));
+    }
+    catch (IllegalArgumentException e) {
+      return Collections.emptyList();
+    }
+    List<SegmentId> possibleParsings = new ArrayList<>(2);
+    String version = DELIMITER_JOINER.join(splits.subList(2, Math.max(splits.size() - 1, 3)));
+    String trail = splits.size() > 3 ? splits.get(splits.size() - 1) : null;
+    if (trail != null) {
+      Integer possiblePartitionNum = Ints.tryParse(trail);
+      if (possiblePartitionNum != null && possiblePartitionNum > 0) {
+        possibleParsings.add(of(dataSource, new Interval(start, end), version, possiblePartitionNum));
+      }
+      version = version + '_' + trail;
+    }
+    possibleParsings.add(of(dataSource, new Interval(start, end), version, 0));
+    return possibleParsings;
+  }
+
+  /**
+   * Heuristically tries to extract the most probable data source from a String segment id representation, or returns
+   * null on failure.
+   *
+   * This method is not guaranteed to return a non-null data source given a valid String segment id representation.
+   */
+  @VisibleForTesting
+  @Nullable
+  static String tryExtractMostProbableDataSource(String segmentId)
+  {
+    Matcher dateTimeMatcher = DateTimes.COMMON_DATE_TIME_PATTERN.matcher(segmentId);
+    while (true) {
+      if (!dateTimeMatcher.find()) {
+        return null;
+      }
+      int dataSourceEnd = dateTimeMatcher.start() - 1;
+      if (segmentId.charAt(dataSourceEnd) != DELIMITER) {
+        continue;
+      }
+      return segmentId.substring(0, dataSourceEnd);
+    }
+  }
+
+  public static Function<String, Interval> makeIntervalExtractor(final String dataSource)
+  {
+    return identifier -> {
+      SegmentId segmentIdentifierParts = tryParse(dataSource, identifier);
+      if (segmentIdentifierParts == null) {
+        throw new IAE("Invalid identifier [%s]", identifier);
+      }
+
+      return segmentIdentifierParts.getInterval();
+    };
+  }
+
+  /**
+   * Creates a dummy SegmentId with the given data source. This method is useful in benchmark and test code.
+   */
+  public static SegmentId dummy(String dataSource)
+  {
+    return of(dataSource, Intervals.ETERNITY, "dummy_version", 0);
+  }
+
+  private final String dataSource;
+  /**
+   * {@code intervalStartMillis}, {@link #intervalEndMillis} and {@link #intervalChronology} are the three fields of
+   * an {@link Interval}. Storing them directly to flatten the structure and reduce the heap space consumption.
+   */
+  private final long intervalStartMillis;
+  private final long intervalEndMillis;
+  @Nullable
+  private final Chronology intervalChronology;
+  private final String version;
+  private final int partitionNum;
+
+  /**
+   * Cache the hash code eagerly, because SegmentId is almost always expected to be used as a map key or
+   * for map lookup.
+   */
+  private final int hashCode;
+
+  private SegmentId(String dataSource, Interval interval, String version, int partitionNum)
+  {
+    this.dataSource = STRING_INTERNER.intern(Objects.requireNonNull(dataSource));
+    this.intervalStartMillis = interval.getStartMillis();
+    this.intervalEndMillis = interval.getEndMillis();
+    this.intervalChronology = interval.getChronology();
+    // Versions are timestamp-based Strings, interning of them doesn't make sense. If this is not the case, interning
+    // could be conditionally allowed via a system property.
+    this.version = Objects.requireNonNull(version);
+    this.partitionNum = partitionNum;
+    this.hashCode = computeHashCode();
+  }
+
+  private int computeHashCode()
+  {
+    // Start with partitionNum and version hash codes, because they are often little sequential numbers. If they are
+    // added in the end of the chain, resulting hashCode of SegmentId could have worse distribution.
+    int hashCode = partitionNum;
+    hashCode = hashCode * 1000003 + version.hashCode();
+
+    hashCode = hashCode * 1000003 + dataSource.hashCode();
+    hashCode = hashCode * 1000003 + Long.hashCode(intervalStartMillis);
+    hashCode = hashCode * 1000003 + Long.hashCode(intervalEndMillis);
+    hashCode = hashCode * 1000003 + Objects.hashCode(intervalChronology);
+    return hashCode;
+  }
+
+  public String getDataSource()
+  {
+    return dataSource;
+  }
+
+  public DateTime getIntervalStart()
+  {
+    return new DateTime(intervalStartMillis, intervalChronology);
+  }
+
+  public DateTime getIntervalEnd()
+  {
+    return new DateTime(intervalEndMillis, intervalChronology);
+  }
+
+  public Interval getInterval()
+  {
+    return new Interval(intervalStartMillis, intervalEndMillis, intervalChronology);
+  }
+
+  @Nullable
+  public String getVersion()
+  {
+    return version;
+  }
+
+  public int getPartitionNum()
+  {
+    return partitionNum;
+  }
+
+  public SegmentId withInterval(Interval newInterval)
+  {
+    return of(dataSource, newInterval, version, partitionNum);
+  }
+
+  @Override
+  public boolean equals(Object o)
+  {
+    if (this == o) {
+      return true;
+    }
+    if (!(o instanceof SegmentId)) {
+      return false;
+    }
+    SegmentId that = (SegmentId) o;
+    // Compare hashCode instead of partitionNum: break the chain quicker if the objects are not equal. If the hashCodes
+    // are equal as well as all other fields used to compute them, the partitionNums are also guaranteed to be equal.
+    return hashCode == that.hashCode &&
+           dataSource.equals(that.dataSource) &&
+           intervalStartMillis == that.intervalStartMillis &&
+           intervalEndMillis == that.intervalEndMillis &&
+           Objects.equals(intervalChronology, that.intervalChronology) &&
+           version.equals(that.version);
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return hashCode;
+  }
+
+  @Override
+  public int compareTo(SegmentId o)
+  {
+    int result = dataSource.compareTo(o.dataSource);
+    if (result != 0) {
+      return result;
+    }
+    result = Long.compare(intervalStartMillis, o.intervalStartMillis);
+    if (result != 0) {
+      return result;
+    }
+    result = Long.compare(intervalEndMillis, o.intervalEndMillis);
+    if (result != 0) {
+      return result;
+    }
+    result = version.compareTo(o.version);
+    if (result != 0) {
+      return result;
+    }
+    return Integer.compare(partitionNum, o.partitionNum);
+  }
+
+  @JsonValue
+  @Override
+  public String toString()
+  {
+    StringBuilder sb = new StringBuilder(safeUpperLimitOfStringSize());
+
+    sb.append(dataSource).append(DELIMITER)
+      .append(getIntervalStart()).append(DELIMITER)
+      .append(getIntervalEnd()).append(DELIMITER)
+      .append(version);
+
+    if (partitionNum != 0) {
+      sb.append(DELIMITER).append(partitionNum);
+    }
+
+    return sb.toString();
+  }
+
+  private int safeUpperLimitOfStringSize()
+  {
+    int delimiters = 4;
+    int partitionNumSizeUpperLimit = 3; // less than 1000 partitions
+    return dataSource.length() +
+           version.length() +
+           (DATE_TIME_SIZE_UPPER_LIMIT * 2) + // interval start and end
+           delimiters +
+           partitionNumSizeUpperLimit;
+  }
+}
diff --git a/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java b/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
index 59a71ff9dbc8..835517117835 100644
--- a/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
+++ b/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
@@ -148,7 +148,7 @@ public void testV1Serialization() throws Exception
     Assert.assertEquals(segment.getMetrics(), deserializedSegment.getMetrics());
     Assert.assertEquals(segment.getShardSpec(), deserializedSegment.getShardSpec());
     Assert.assertEquals(segment.getSize(), deserializedSegment.getSize());
-    Assert.assertEquals(segment.getIdentifier(), deserializedSegment.getIdentifier());
+    Assert.assertEquals(segment.getId(), deserializedSegment.getId());
 
     deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
     Assert.assertEquals(0, segment.compareTo(deserializedSegment));
@@ -172,7 +172,7 @@ public void testIdentifier()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getIdentifier()
+        segment.getId()
     );
   }
 
@@ -188,7 +188,7 @@ public void testIdentifierWithZeroPartition()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getIdentifier()
+        segment.getId()
     );
   }
 
@@ -204,7 +204,7 @@ public void testIdentifierWithNonzeroPartition()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z_7",
-        segment.getIdentifier()
+        segment.getId()
     );
   }
 
diff --git a/api/src/test/java/org/apache/druid/timeline/DataSegmentUtilsTest.java b/api/src/test/java/org/apache/druid/timeline/DataSegmentUtilsTest.java
deleted file mode 100644
index 3fc81a2b9cad..000000000000
--- a/api/src/test/java/org/apache/druid/timeline/DataSegmentUtilsTest.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.timeline;
-
-import org.apache.druid.java.util.common.Intervals;
-import org.apache.druid.timeline.DataSegmentUtils.SegmentIdentifierParts;
-import org.junit.Assert;
-import org.junit.Test;
-
-/**
- */
-public class DataSegmentUtilsTest
-{
-  @Test
-  public void testBasic()
-  {
-    String datasource = "datasource";
-    SegmentIdentifierParts desc = new SegmentIdentifierParts(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver", "0_0");
-    Assert.assertEquals("datasource_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_0", desc.toString());
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(datasource, desc.toString()));
-
-    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
-    Assert.assertEquals("datasource_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver_0_0", desc.toString());
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(datasource, desc.toString()));
-
-    desc = new SegmentIdentifierParts(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver", null);
-    Assert.assertEquals("datasource_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver", desc.toString());
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(datasource, desc.toString()));
-
-    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
-    Assert.assertEquals("datasource_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver", desc.toString());
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(datasource, desc.toString()));
-  }
-
-  @Test
-  public void testDataSourceWithUnderscore1()
-  {
-    String datasource = "datasource_1";
-    SegmentIdentifierParts desc = new SegmentIdentifierParts(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver", "0_0");
-    Assert.assertEquals("datasource_1_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_0", desc.toString());
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(datasource, desc.toString()));
-
-    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
-    Assert.assertEquals("datasource_1_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver_0_0", desc.toString());
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(datasource, desc.toString()));
-
-    desc = new SegmentIdentifierParts(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver", null);
-    Assert.assertEquals("datasource_1_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver", desc.toString());
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(datasource, desc.toString()));
-
-    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
-    Assert.assertEquals("datasource_1_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver", desc.toString());
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(datasource, desc.toString()));
-  }
-
-  @Test
-  public void testDataSourceWithUnderscore2()
-  {
-    String dataSource = "datasource_2015-01-01T00:00:00.000Z";
-    SegmentIdentifierParts desc = new SegmentIdentifierParts(dataSource, Intervals.of("2015-01-02/2015-01-03"), "ver", "0_0");
-    Assert.assertEquals(
-        "datasource_2015-01-01T00:00:00.000Z_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_0",
-        desc.toString()
-    );
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(dataSource, desc.toString()));
-
-    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
-    Assert.assertEquals(
-        "datasource_2015-01-01T00:00:00.000Z_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver_0_0",
-        desc.toString()
-    );
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(dataSource, desc.toString()));
-
-    desc = new SegmentIdentifierParts(dataSource, Intervals.of("2015-01-02/2015-01-03"), "ver", null);
-    Assert.assertEquals(
-        "datasource_2015-01-01T00:00:00.000Z_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver",
-        desc.toString()
-    );
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(dataSource, desc.toString()));
-
-    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
-    Assert.assertEquals(
-        "datasource_2015-01-01T00:00:00.000Z_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver",
-        desc.toString()
-    );
-    Assert.assertEquals(desc, DataSegmentUtils.valueOf(dataSource, desc.toString()));
-  }
-
-  @Test
-  public void testInvalidFormat0()
-  {
-    Assert.assertNull(DataSegmentUtils.valueOf("ds", "datasource_2015-01-02T00:00:00.000Z_2014-10-20T00:00:00.000Z_version"));
-  }
-
-  @Test
-  public void testInvalidFormat1()
-  {
-    Assert.assertNull(DataSegmentUtils.valueOf("datasource", "datasource_invalid_interval_version"));
-  }
-
-  @Test
-  public void testInvalidFormat2()
-  {
-    Assert.assertNull(DataSegmentUtils.valueOf("datasource", "datasource_2015-01-02T00:00:00.000Z_version"));
-  }
-}
diff --git a/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java b/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
new file mode 100644
index 000000000000..ffbd7d311d8b
--- /dev/null
+++ b/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.timeline;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import org.apache.druid.java.util.common.DateTimes;
+import org.apache.druid.java.util.common.Intervals;
+import org.joda.time.DateTime;
+import org.joda.time.Interval;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+
+public class SegmentIdTest
+{
+  @Test
+  public void testBasic()
+  {
+    String datasource = "datasource";
+    SegmentId desc = SegmentId.of(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver_0", 1);
+    Assert.assertEquals("datasource_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_1", desc.toString());
+    Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
+
+    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
+    Assert.assertEquals("datasource_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver_0_1", desc.toString());
+    Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
+
+    desc = SegmentId.of(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver", 0);
+    Assert.assertEquals("datasource_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver", desc.toString());
+    Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
+
+    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
+    Assert.assertEquals("datasource_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver", desc.toString());
+    Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
+  }
+
+  @Test
+  public void testDataSourceWithUnderscore1()
+  {
+    String datasource = "datasource_1";
+    SegmentId desc = SegmentId.of(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver_0", 1);
+    Assert.assertEquals("datasource_1_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_1", desc.toString());
+    Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
+
+    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
+    Assert.assertEquals("datasource_1_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver_0_1", desc.toString());
+    Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
+
+    desc = SegmentId.of(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver", 0);
+    Assert.assertEquals("datasource_1_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver", desc.toString());
+    Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
+
+    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
+    Assert.assertEquals("datasource_1_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver", desc.toString());
+    Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
+  }
+
+  @Test
+  public void testDataSourceWithUnderscore2()
+  {
+    String dataSource = "datasource_2015-01-01T00:00:00.000Z";
+    SegmentId desc = SegmentId.of(dataSource, Intervals.of("2015-01-02/2015-01-03"), "ver_0", 1);
+    Assert.assertEquals(
+        "datasource_2015-01-01T00:00:00.000Z_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_1",
+        desc.toString()
+    );
+    Assert.assertEquals(desc, SegmentId.tryParse(dataSource, desc.toString()));
+
+    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
+    Assert.assertEquals(
+        "datasource_2015-01-01T00:00:00.000Z_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver_0_1",
+        desc.toString()
+    );
+    Assert.assertEquals(desc, SegmentId.tryParse(dataSource, desc.toString()));
+
+    desc = SegmentId.of(dataSource, Intervals.of("2015-01-02/2015-01-03"), "ver", 0);
+    Assert.assertEquals(
+        "datasource_2015-01-01T00:00:00.000Z_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver",
+        desc.toString()
+    );
+    Assert.assertEquals(desc, SegmentId.tryParse(dataSource, desc.toString()));
+
+    desc = desc.withInterval(Intervals.of("2014-10-20T00:00:00Z/P1D"));
+    Assert.assertEquals(
+        "datasource_2015-01-01T00:00:00.000Z_2014-10-20T00:00:00.000Z_2014-10-21T00:00:00.000Z_ver",
+        desc.toString()
+    );
+    Assert.assertEquals(desc, SegmentId.tryParse(dataSource, desc.toString()));
+  }
+
+  @Test
+  public void testInvalidFormat0()
+  {
+    Assert.assertNull(SegmentId.tryParse("ds", "datasource_2015-01-02T00:00:00.000Z_2014-10-20T00:00:00.000Z_version"));
+  }
+
+  @Test
+  public void testInvalidFormat1()
+  {
+    Assert.assertNull(SegmentId.tryParse("datasource", "datasource_invalid_interval_version"));
+  }
+
+  @Test
+  public void testInvalidFormat2()
+  {
+    Assert.assertNull(SegmentId.tryParse("datasource", "datasource_2015-01-02T00:00:00.000Z_version"));
+  }
+
+  /**
+   * Tests that {@link SegmentId#tryExtractMostProbableDataSource} successfully extracts data sources from some
+   * reasonable segment ids.
+   */
+  @Test
+  public void testTryParseHeuristically()
+  {
+    List<String> segmentIds = Arrays.asList(
+        "datasource_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_1",
+        "datasource_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver",
+        "datasource_1_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_1",
+        "datasource_1_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver",
+        "datasource_2015-01-01T00:00:00.000Z_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_1",
+        "datasource_2015-01-01T00:00:00.000Z_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver"
+    );
+    for (String segmentId : segmentIds) {
+      String dataSource = SegmentId.tryExtractMostProbableDataSource(segmentId);
+      Assert.assertTrue("datasource".equals(dataSource) || "datasource_1".equals(dataSource));
+      Assert.assertTrue(!SegmentId.iteratePossibleParsingsWithDataSource(dataSource, segmentId).isEmpty());
+    }
+  }
+
+  @Test
+  public void testTryParseVersionAmbiguity()
+  {
+    SegmentId segmentId =
+        SegmentId.tryParse("datasource", "datasource_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0");
+    Assert.assertNotNull(segmentId);
+    Assert.assertEquals("ver_0", segmentId.getVersion());
+    Assert.assertEquals(0, segmentId.getPartitionNum());
+  }
+
+  @Test
+  public void testIterateAllPossibleParsings()
+  {
+    String segmentId = "datasource_2015-01-01T00:00:00.000Z_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_ver_0_1";
+    List<SegmentId> possibleParsings = ImmutableList.copyOf(SegmentId.iterateAllPossibleParsings(segmentId));
+    DateTime dt1 = DateTimes.of("2015-01-01T00:00:00.000Z");
+    DateTime dt2 = DateTimes.of("2015-01-02T00:00:00.000Z");
+    DateTime dt3 = DateTimes.of("2015-01-03T00:00:00.000Z");
+    Set<SegmentId> expected = ImmutableSet.of(
+        SegmentId.of("datasource", new Interval(dt1, dt2), "2015-01-03T00:00:00.000Z_ver_0", 1),
+        SegmentId.of("datasource", new Interval(dt1, dt2), "2015-01-03T00:00:00.000Z_ver_0_1", 0),
+        SegmentId.of("datasource_2015-01-01T00:00:00.000Z", new Interval(dt2, dt3), "ver_0", 1),
+        SegmentId.of("datasource_2015-01-01T00:00:00.000Z", new Interval(dt2, dt3), "ver_0_1", 0)
+    );
+    Assert.assertEquals(4, possibleParsings.size());
+    Assert.assertEquals(expected, ImmutableSet.copyOf(possibleParsings));
+  }
+}
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/FilteredAggregatorBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/FilteredAggregatorBenchmark.java
index adb19debb906..df9e3d0d9f4a 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/FilteredAggregatorBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/FilteredAggregatorBenchmark.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.Maps;
 import com.google.common.io.Files;
+import org.apache.commons.io.FileUtils;
 import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator;
 import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo;
 import org.apache.druid.benchmark.datagen.BenchmarkSchemas;
@@ -71,7 +72,7 @@
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
-import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -267,8 +268,8 @@ public void querySingleIncrementalIndex(Blackhole blackhole)
   {
     QueryRunner<Result<TimeseriesResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "incIndex",
-        new IncrementalIndexSegment(incIndex, "incIndex")
+        SegmentId.dummy("incIndex"),
+        new IncrementalIndexSegment(incIndex, SegmentId.dummy("incIndex"))
     );
 
     List<Result<TimeseriesResultValue>> results = FilteredAggregatorBenchmark.runQuery(factory, runner, query);
@@ -284,8 +285,8 @@ public void querySingleQueryableIndex(Blackhole blackhole)
   {
     final QueryRunner<Result<TimeseriesResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndex)
+        SegmentId.dummy("qIndex"),
+        new QueryableIndexSegment(qIndex, SegmentId.dummy("qIndex"))
     );
 
     List<Result<TimeseriesResultValue>> results = FilteredAggregatorBenchmark.runQuery(factory, runner, query);
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/GroupByTypeInterfaceBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/GroupByTypeInterfaceBenchmark.java
index 5b9901ef9332..142b97fdb8bb 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/GroupByTypeInterfaceBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/GroupByTypeInterfaceBenchmark.java
@@ -26,6 +26,7 @@
 import com.google.common.base.Throwables;
 import com.google.common.collect.Maps;
 import com.google.common.io.Files;
+import org.apache.commons.io.FileUtils;
 import org.apache.druid.benchmark.datagen.BenchmarkDataGenerator;
 import org.apache.druid.benchmark.datagen.BenchmarkSchemaInfo;
 import org.apache.druid.benchmark.datagen.BenchmarkSchemas;
@@ -73,7 +74,7 @@
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
-import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -108,6 +109,8 @@
 @Measurement(iterations = 30)
 public class GroupByTypeInterfaceBenchmark
 {
+  private static final SegmentId Q_INDEX_SEGMENT_ID = SegmentId.dummy("qIndex");
+  
   @Param({"4"})
   private int numSegments;
 
@@ -463,8 +466,8 @@ public void querySingleQueryableIndexStringOnly(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -481,8 +484,8 @@ public void querySingleQueryableIndexLongOnly(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -499,8 +502,8 @@ public void querySingleQueryableIndexFloatOnly(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -517,8 +520,8 @@ public void querySingleQueryableIndexNumericOnly(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longFloatQuery);
@@ -535,8 +538,8 @@ public void querySingleQueryableIndexNumericThenString(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longFloatQuery);
@@ -547,8 +550,8 @@ public void querySingleQueryableIndexNumericThenString(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -566,8 +569,8 @@ public void querySingleQueryableIndexLongThenString(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -578,8 +581,8 @@ public void querySingleQueryableIndexLongThenString(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -596,8 +599,8 @@ public void querySingleQueryableIndexLongThenFloat(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -608,8 +611,8 @@ public void querySingleQueryableIndexLongThenFloat(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -626,8 +629,8 @@ public void querySingleQueryableIndexStringThenNumeric(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -638,8 +641,8 @@ public void querySingleQueryableIndexStringThenNumeric(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longFloatQuery);
@@ -656,8 +659,8 @@ public void querySingleQueryableIndexStringThenLong(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -668,8 +671,8 @@ public void querySingleQueryableIndexStringThenLong(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -686,8 +689,8 @@ public void querySingleQueryableIndexStringTwice(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -698,8 +701,8 @@ public void querySingleQueryableIndexStringTwice(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -716,8 +719,8 @@ public void querySingleQueryableIndexLongTwice(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -728,8 +731,8 @@ public void querySingleQueryableIndexLongTwice(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -747,8 +750,8 @@ public void querySingleQueryableIndexFloatTwice(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -759,8 +762,8 @@ public void querySingleQueryableIndexFloatTwice(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -777,8 +780,8 @@ public void querySingleQueryableIndexFloatThenLong(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -789,8 +792,8 @@ public void querySingleQueryableIndexFloatThenLong(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -807,8 +810,8 @@ public void querySingleQueryableIndexFloatThenString(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Row> results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -819,8 +822,8 @@ public void querySingleQueryableIndexFloatThenString(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(queryableIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = GroupByTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/LoadStatusBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/LoadStatusBenchmark.java
index 0bc82f5024af..6225780eeea1 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/LoadStatusBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/LoadStatusBenchmark.java
@@ -25,6 +25,7 @@
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
@@ -67,10 +68,10 @@ public class LoadStatusBenchmark
   @Setup(Level.Invocation)
   public void setup()
   {
-    Map<String, DataSegment> immutableDatasourceSegmentsMap;
-    ConcurrentHashMap<String, DataSegment> serverSegmentsMap;
+    Map<SegmentId, DataSegment> immutableDatasourceSegmentsMap;
+    ConcurrentHashMap<SegmentId, DataSegment> serverSegmentsMap;
 
-    HashMap<String, DataSegment> datasourceSegmentsMap = Maps.newHashMap();
+    HashMap<SegmentId, DataSegment> datasourceSegmentsMap = Maps.newHashMap();
     serverSegmentsMap = new ConcurrentHashMap<>();
 
     for (int i = 0; i < totalSegmentsCount; i++) {
@@ -86,10 +87,10 @@ public void setup()
           1
       );
 
-      datasourceSegmentsMap.put(segment.getIdentifier(), segment);
+      datasourceSegmentsMap.put(segment.getId(), segment);
 
       if (serverHasAllSegments || i % 2 == 0) {
-        serverSegmentsMap.put(segment.getIdentifier(), segment);
+        serverSegmentsMap.put(segment.getId(), segment);
       }
     }
 
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/TopNTypeInterfaceBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/TopNTypeInterfaceBenchmark.java
index d5d97a46eb39..a98c3c600977 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/TopNTypeInterfaceBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/TopNTypeInterfaceBenchmark.java
@@ -69,6 +69,7 @@
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.SegmentId;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -99,6 +100,8 @@
 @Measurement(iterations = 25)
 public class TopNTypeInterfaceBenchmark
 {
+  private static final SegmentId Q_INDEX_SEGMENT_ID = SegmentId.dummy("qIndex");
+  
   @Param({"1"})
   private int numSegments;
 
@@ -331,8 +334,8 @@ public void querySingleQueryableIndexStringOnly(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -348,8 +351,8 @@ public void querySingleQueryableIndexStringTwice(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -359,8 +362,8 @@ public void querySingleQueryableIndexStringTwice(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -376,8 +379,8 @@ public void querySingleQueryableIndexStringThenLong(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -387,8 +390,8 @@ public void querySingleQueryableIndexStringThenLong(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -404,8 +407,8 @@ public void querySingleQueryableIndexStringThenFloat(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -415,8 +418,8 @@ public void querySingleQueryableIndexStringThenFloat(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -432,8 +435,8 @@ public void querySingleQueryableIndexLongOnly(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -449,8 +452,8 @@ public void querySingleQueryableIndexLongTwice(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -460,8 +463,8 @@ public void querySingleQueryableIndexLongTwice(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -477,8 +480,8 @@ public void querySingleQueryableIndexLongThenString(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -488,8 +491,8 @@ public void querySingleQueryableIndexLongThenString(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -505,8 +508,8 @@ public void querySingleQueryableIndexLongThenFloat(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
@@ -516,8 +519,8 @@ public void querySingleQueryableIndexLongThenFloat(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -533,8 +536,8 @@ public void querySingleQueryableIndexFloatOnly(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -550,8 +553,8 @@ public void querySingleQueryableIndexFloatTwice(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -561,8 +564,8 @@ public void querySingleQueryableIndexFloatTwice(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -578,8 +581,8 @@ public void querySingleQueryableIndexFloatThenString(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -589,8 +592,8 @@ public void querySingleQueryableIndexFloatThenString(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, stringQuery);
@@ -606,8 +609,8 @@ public void querySingleQueryableIndexFloatThenLong(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     List<Result<TopNResultValue>> results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, floatQuery);
@@ -617,8 +620,8 @@ public void querySingleQueryableIndexFloatThenLong(Blackhole blackhole)
 
     runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        Q_INDEX_SEGMENT_ID,
+        new QueryableIndexSegment(qIndexes.get(0), Q_INDEX_SEGMENT_ID)
     );
 
     results = TopNTypeInterfaceBenchmark.runQuery(factory, runner, longQuery);
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java
index dd339072584e..acedf137c95e 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/datagen/SegmentGenerator.java
@@ -23,6 +23,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.io.Files;
+import org.apache.commons.io.FileUtils;
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.data.input.impl.DimensionSchema;
 import org.apache.druid.data.input.impl.DimensionsSpec;
@@ -33,7 +34,6 @@
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.granularity.Granularity;
 import org.apache.druid.java.util.common.logger.Logger;
-import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.druid.query.aggregation.AggregatorFactory;
 import org.apache.druid.query.aggregation.hyperloglog.HyperUniquesSerde;
 import org.apache.druid.segment.IndexBuilder;
@@ -43,8 +43,9 @@
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.segment.serde.ComplexMetrics;
+import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.druid.timeline.DataSegment;
-import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 
 import java.io.Closeable;
 import java.io.File;
@@ -127,7 +128,7 @@ public QueryableIndex generate(
       }
 
       if (rows.size() % MAX_ROWS_IN_MEMORY == 0) {
-        indexes.add(makeIndex(dataSegment.getIdentifier(), indexes.size(), rows, indexSchema));
+        indexes.add(makeIndex(dataSegment.getId(), indexes.size(), rows, indexSchema));
         rows.clear();
       }
     }
@@ -135,7 +136,7 @@ public QueryableIndex generate(
     log.info("%,d/%,d rows generated.", numRows, numRows);
 
     if (rows.size() > 0) {
-      indexes.add(makeIndex(dataSegment.getIdentifier(), indexes.size(), rows, indexSchema));
+      indexes.add(makeIndex(dataSegment.getId(), indexes.size(), rows, indexSchema));
       rows.clear();
     }
 
@@ -177,7 +178,7 @@ public void close() throws IOException
   }
 
   private QueryableIndex makeIndex(
-      final String identifier,
+      final SegmentId identifier,
       final int indexNumber,
       final List<InputRow> rows,
       final IncrementalIndexSchema indexSchema
@@ -186,7 +187,7 @@ private QueryableIndex makeIndex(
     return IndexBuilder
         .create()
         .schema(indexSchema)
-        .tmpDir(new File(new File(tempDir, identifier), String.valueOf(indexNumber)))
+        .tmpDir(new File(new File(tempDir, identifier.toString()), String.valueOf(indexNumber)))
         .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
         .rows(rows)
         .buildMMappedIndex();
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java
index 84237ee60136..5173229d84b5 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/GroupByBenchmark.java
@@ -83,6 +83,7 @@
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -559,8 +560,8 @@ public void querySingleIncrementalIndex(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "incIndex",
-        new IncrementalIndexSegment(anIncrementalIndex, "incIndex")
+        SegmentId.dummy("incIndex"),
+        new IncrementalIndexSegment(anIncrementalIndex, SegmentId.dummy("incIndex"))
     );
 
     List<Row> results = GroupByBenchmark.runQuery(factory, runner, query);
@@ -577,8 +578,8 @@ public void querySingleQueryableIndex(Blackhole blackhole)
   {
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", queryableIndexes.get(0))
+        SegmentId.dummy("qIndex"),
+        new QueryableIndexSegment(queryableIndexes.get(0), SegmentId.dummy("qIndex"))
     );
 
     List<Row> results = GroupByBenchmark.runQuery(factory, runner, query);
@@ -667,8 +668,8 @@ private List<QueryRunner<Row>> makeMultiRunners()
       String segmentName = "qIndex" + i;
       QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
           factory,
-          segmentName,
-          new QueryableIndexSegment(segmentName, queryableIndexes.get(i))
+          SegmentId.dummy(segmentName),
+          new QueryableIndexSegment(queryableIndexes.get(i), SegmentId.dummy(segmentName))
       );
       runners.add(factory.getToolchest().preMergeQueryDecoration(runner));
     }
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/QueryBenchmarkUtil.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/QueryBenchmarkUtil.java
index fdde8bfedc09..9a3a7037b95c 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/QueryBenchmarkUtil.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/QueryBenchmarkUtil.java
@@ -31,6 +31,7 @@
 import org.apache.druid.query.QueryToolChest;
 import org.apache.druid.query.QueryWatcher;
 import org.apache.druid.segment.Segment;
+import org.apache.druid.timeline.SegmentId;
 
 import java.util.Map;
 
@@ -38,13 +39,14 @@ public class QueryBenchmarkUtil
 {
   public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner(
       QueryRunnerFactory<T, QueryType> factory,
-      String segmentId,
+      SegmentId segmentId,
       Segment adapter
   )
   {
-    return new FinalizeResultsQueryRunner<T>(
-        new BySegmentQueryRunner<T>(
-            segmentId, adapter.getDataInterval().getStart(),
+    return new FinalizeResultsQueryRunner<>(
+        new BySegmentQueryRunner<>(
+            segmentId,
+            adapter.getDataInterval().getStart(),
             factory.createRunner(adapter)
         ),
         (QueryToolChest<T, Query<T>>) factory.getToolchest()
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SearchBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SearchBenchmark.java
index 5e3c6bed2096..0d6f7688a3da 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SearchBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SearchBenchmark.java
@@ -78,6 +78,7 @@
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -414,8 +415,8 @@ public void querySingleIncrementalIndex(Blackhole blackhole)
   {
     QueryRunner<SearchHit> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "incIndex",
-        new IncrementalIndexSegment(incIndexes.get(0), "incIndex")
+        SegmentId.dummy("incIndex"),
+        new IncrementalIndexSegment(incIndexes.get(0), SegmentId.dummy("incIndex"))
     );
 
     List<Result<SearchResultValue>> results = SearchBenchmark.runQuery(factory, runner, query);
@@ -432,8 +433,8 @@ public void querySingleQueryableIndex(Blackhole blackhole)
   {
     final QueryRunner<Result<SearchResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        SegmentId.dummy("qIndex"),
+        new QueryableIndexSegment(qIndexes.get(0), SegmentId.dummy("qIndex"))
     );
 
     List<Result<SearchResultValue>> results = SearchBenchmark.runQuery(factory, runner, query);
@@ -455,8 +456,8 @@ public void queryMultiQueryableIndex(Blackhole blackhole)
       String segmentName = "qIndex" + i;
       final QueryRunner<Result<SearchResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
           factory,
-          segmentName,
-          new QueryableIndexSegment(segmentName, qIndexes.get(i))
+          SegmentId.dummy(segmentName),
+          new QueryableIndexSegment(qIndexes.get(i), SegmentId.dummy(segmentName))
       );
       singleSegmentRunners.add(toolChest.preMergeQueryDecoration(runner));
     }
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SelectBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SelectBenchmark.java
index abee67d5a65f..b1437f3b1ddb 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SelectBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SelectBenchmark.java
@@ -68,6 +68,7 @@
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -293,7 +294,7 @@ public void queryIncrementalIndex(Blackhole blackhole)
   {
     SelectQuery queryCopy = query.withPagingSpec(PagingSpec.newSpec(pagingThreshold));
 
-    String segmentId = "incIndex";
+    SegmentId segmentId = SegmentId.dummy("incIndex");
     QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
         segmentId,
@@ -323,11 +324,11 @@ public void queryQueryableIndex(Blackhole blackhole)
   {
     SelectQuery queryCopy = query.withPagingSpec(PagingSpec.newSpec(pagingThreshold));
 
-    String segmentId = "qIndex";
+    SegmentId segmentId = SegmentId.dummy("qIndex");
     QueryRunner<Result<SelectResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
         segmentId,
-        new QueryableIndexSegment(segmentId, qIndexes.get(0))
+        new QueryableIndexSegment(qIndexes.get(0), segmentId)
     );
 
     boolean done = false;
@@ -353,15 +354,14 @@ public void queryMultiQueryableIndex(Blackhole blackhole)
   {
     SelectQuery queryCopy = query.withPagingSpec(PagingSpec.newSpec(pagingThreshold));
 
-    String segmentName;
     List<QueryRunner<Result<SelectResultValue>>> singleSegmentRunners = Lists.newArrayList();
     QueryToolChest toolChest = factory.getToolchest();
     for (int i = 0; i < numSegments; i++) {
-      segmentName = "qIndex" + i;
+      SegmentId segmentId = SegmentId.dummy("qIndex" + i);
       QueryRunner<Result<SelectResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
           factory,
-          segmentName,
-          new QueryableIndexSegment(segmentName, qIndexes.get(i))
+          segmentId,
+          new QueryableIndexSegment(qIndexes.get(i), segmentId)
       );
       singleSegmentRunners.add(toolChest.preMergeQueryDecoration(runner));
     }
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/TimeseriesBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/TimeseriesBenchmark.java
index d26cfebdf0fc..ae96d9f93e51 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/TimeseriesBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/TimeseriesBenchmark.java
@@ -73,6 +73,7 @@
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -338,8 +339,8 @@ public void querySingleIncrementalIndex(Blackhole blackhole)
   {
     QueryRunner<Result<TimeseriesResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "incIndex",
-        new IncrementalIndexSegment(incIndexes.get(0), "incIndex")
+        SegmentId.dummy("incIndex"),
+        new IncrementalIndexSegment(incIndexes.get(0), SegmentId.dummy("incIndex"))
     );
 
     List<Result<TimeseriesResultValue>> results = TimeseriesBenchmark.runQuery(factory, runner, query);
@@ -355,8 +356,8 @@ public void querySingleQueryableIndex(Blackhole blackhole)
   {
     final QueryRunner<Result<TimeseriesResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        SegmentId.dummy("qIndex"),
+        new QueryableIndexSegment(qIndexes.get(0), SegmentId.dummy("qIndex"))
     );
 
     List<Result<TimeseriesResultValue>> results = TimeseriesBenchmark.runQuery(factory, runner, query);
@@ -372,8 +373,8 @@ public void queryFilteredSingleQueryableIndex(Blackhole blackhole)
   {
     final QueryRunner<Result<TimeseriesResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        SegmentId.dummy("qIndex"),
+        new QueryableIndexSegment(qIndexes.get(0), SegmentId.dummy("qIndex"))
     );
 
     DimFilter filter = new SelectorDimFilter("dimSequential", "399", null);
@@ -393,11 +394,11 @@ public void queryMultiQueryableIndex(Blackhole blackhole)
     List<QueryRunner<Result<TimeseriesResultValue>>> singleSegmentRunners = Lists.newArrayList();
     QueryToolChest toolChest = factory.getToolchest();
     for (int i = 0; i < numSegments; i++) {
-      String segmentName = "qIndex" + i;
+      SegmentId segmentId = SegmentId.dummy("qIndex" + i);
       QueryRunner<Result<TimeseriesResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
           factory,
-          segmentName,
-          new QueryableIndexSegment(segmentName, qIndexes.get(i))
+          segmentId,
+          new QueryableIndexSegment(qIndexes.get(i), segmentId)
       );
       singleSegmentRunners.add(toolChest.preMergeQueryDecoration(runner));
     }
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/TopNBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/TopNBenchmark.java
index 4d883e917693..c7d751acea55 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/TopNBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/TopNBenchmark.java
@@ -70,6 +70,7 @@
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
@@ -319,8 +320,8 @@ public void querySingleIncrementalIndex(Blackhole blackhole)
   {
     QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "incIndex",
-        new IncrementalIndexSegment(incIndexes.get(0), "incIndex")
+        SegmentId.dummy("incIndex"),
+        new IncrementalIndexSegment(incIndexes.get(0), SegmentId.dummy("incIndex"))
     );
 
     List<Result<TopNResultValue>> results = TopNBenchmark.runQuery(factory, runner, query);
@@ -336,8 +337,8 @@ public void querySingleQueryableIndex(Blackhole blackhole)
   {
     final QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
         factory,
-        "qIndex",
-        new QueryableIndexSegment("qIndex", qIndexes.get(0))
+        SegmentId.dummy("qIndex"),
+        new QueryableIndexSegment(qIndexes.get(0), SegmentId.dummy("qIndex"))
     );
 
     List<Result<TopNResultValue>> results = TopNBenchmark.runQuery(factory, runner, query);
@@ -354,11 +355,11 @@ public void queryMultiQueryableIndex(Blackhole blackhole)
     List<QueryRunner<Result<TopNResultValue>>> singleSegmentRunners = Lists.newArrayList();
     QueryToolChest toolChest = factory.getToolchest();
     for (int i = 0; i < numSegments; i++) {
-      String segmentName = "qIndex" + i;
+      SegmentId segmentId = SegmentId.dummy("qIndex" + i);
       QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
           factory,
-          segmentName,
-          new QueryableIndexSegment(segmentName, qIndexes.get(i))
+          segmentId,
+          new QueryableIndexSegment(qIndexes.get(i), segmentId)
       );
       singleSegmentRunners.add(toolChest.preMergeQueryDecoration(runner));
     }
diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/timecompare/TimeCompareBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/timecompare/TimeCompareBenchmark.java
index 13318b5d453f..b1b1799a7cd2 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/timecompare/TimeCompareBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/timecompare/TimeCompareBenchmark.java
@@ -76,6 +76,7 @@
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
@@ -357,11 +358,11 @@ public void setup() throws IOException
     List<QueryRunner<Result<TopNResultValue>>> singleSegmentRunners = Lists.newArrayList();
     QueryToolChest toolChest = topNFactory.getToolchest();
     for (int i = 0; i < numSegments; i++) {
-      String segmentName = "qIndex" + i;
+      SegmentId segmentId = SegmentId.dummy("qIndex" + i);
       QueryRunner<Result<TopNResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
           topNFactory,
-          segmentName,
-          new QueryableIndexSegment(segmentName, qIndexes.get(i))
+          segmentId,
+          new QueryableIndexSegment(qIndexes.get(i), segmentId)
       );
       singleSegmentRunners.add(
           new PerSegmentOptimizingQueryRunner<>(
@@ -383,11 +384,11 @@ public void setup() throws IOException
     List<QueryRunner<Result<TimeseriesResultValue>>> singleSegmentRunnersT = Lists.newArrayList();
     QueryToolChest toolChestT = timeseriesFactory.getToolchest();
     for (int i = 0; i < numSegments; i++) {
-      String segmentName = "qIndex" + i;
+      SegmentId segmentId = SegmentId.dummy("qIndex" + i);
       QueryRunner<Result<TimeseriesResultValue>> runner = QueryBenchmarkUtil.makeQueryRunner(
           timeseriesFactory,
-          segmentName,
-          new QueryableIndexSegment(segmentName, qIndexes.get(i))
+          segmentId,
+          new QueryableIndexSegment(qIndexes.get(i), segmentId)
       );
       singleSegmentRunnersT.add(
           new PerSegmentOptimizingQueryRunner<>(
diff --git a/extensions-contrib/azure-extensions/src/main/java/org/apache/druid/storage/azure/AzureDataSegmentKiller.java b/extensions-contrib/azure-extensions/src/main/java/org/apache/druid/storage/azure/AzureDataSegmentKiller.java
index 5d257209a464..87774a36dbca 100644
--- a/extensions-contrib/azure-extensions/src/main/java/org/apache/druid/storage/azure/AzureDataSegmentKiller.java
+++ b/extensions-contrib/azure-extensions/src/main/java/org/apache/druid/storage/azure/AzureDataSegmentKiller.java
@@ -59,10 +59,12 @@ public void kill(DataSegment segment) throws SegmentLoadingException
       azureStorage.emptyCloudBlobDirectory(containerName, dirPath);
     }
     catch (StorageException e) {
-      throw new SegmentLoadingException(e, "Couldn't kill segment[%s]: [%s]", segment.getIdentifier(), e.getExtendedErrorInformation() == null ? null : e.getExtendedErrorInformation().getErrorMessage());
+      Object extendedInfo =
+          e.getExtendedErrorInformation() == null ? null : e.getExtendedErrorInformation().getErrorMessage();
+      throw new SegmentLoadingException(e, "Couldn't kill segment[%s]: [%s]", segment.getId(), extendedInfo);
     }
     catch (URISyntaxException e) {
-      throw new SegmentLoadingException(e, "Couldn't kill segment[%s]: [%s]", segment.getIdentifier(), e.getReason());
+      throw new SegmentLoadingException(e, "Couldn't kill segment[%s]: [%s]", segment.getId(), e.getReason());
     }
   }
 
diff --git a/extensions-contrib/cloudfiles-extensions/src/main/java/org/apache/druid/storage/cloudfiles/CloudFilesDataSegmentPusher.java b/extensions-contrib/cloudfiles-extensions/src/main/java/org/apache/druid/storage/cloudfiles/CloudFilesDataSegmentPusher.java
index 11d5352fa4aa..e2aee91e649a 100644
--- a/extensions-contrib/cloudfiles-extensions/src/main/java/org/apache/druid/storage/cloudfiles/CloudFilesDataSegmentPusher.java
+++ b/extensions-contrib/cloudfiles-extensions/src/main/java/org/apache/druid/storage/cloudfiles/CloudFilesDataSegmentPusher.java
@@ -88,7 +88,7 @@ public DataSegment push(final File indexFilesDir, final DataSegment inSegment, f
 
       final long indexSize = CompressionUtils.zip(indexFilesDir, zipOutFile);
 
-      log.info("Copying segment[%s] to CloudFiles at location[%s]", inSegment.getIdentifier(), segmentPath);
+      log.info("Copying segment[%s] to CloudFiles at location[%s]", inSegment.getId(), segmentPath);
       return CloudFilesUtils.retryCloudFilesOperation(
           () -> {
             CloudFilesObject segmentData = new CloudFilesObject(
diff --git a/extensions-contrib/google-extensions/src/main/java/org/apache/druid/storage/google/GoogleDataSegmentFinder.java b/extensions-contrib/google-extensions/src/main/java/org/apache/druid/storage/google/GoogleDataSegmentFinder.java
index 888a2364bb42..a81de841efd5 100644
--- a/extensions-contrib/google-extensions/src/main/java/org/apache/druid/storage/google/GoogleDataSegmentFinder.java
+++ b/extensions-contrib/google-extensions/src/main/java/org/apache/druid/storage/google/GoogleDataSegmentFinder.java
@@ -82,7 +82,7 @@ public Set<DataSegment> findSegments(String workingDirPath, boolean updateDescri
                 InputStream is = storage.get(item.getBucket(), item.getName());
                 final DataSegment dataSegment = jsonMapper.readValue(is, DataSegment.class);
 
-                LOG.info("Found segment [%s] located at [%s]", dataSegment.getIdentifier(), indexZip);
+                LOG.info("Found segment [%s] located at [%s]", dataSegment.getId(), indexZip);
 
                 Map<String, Object> loadSpec = dataSegment.getLoadSpec();
 
diff --git a/extensions-contrib/google-extensions/src/main/java/org/apache/druid/storage/google/GoogleDataSegmentKiller.java b/extensions-contrib/google-extensions/src/main/java/org/apache/druid/storage/google/GoogleDataSegmentKiller.java
index b3f11c481e0e..e25a5d6c9030 100644
--- a/extensions-contrib/google-extensions/src/main/java/org/apache/druid/storage/google/GoogleDataSegmentKiller.java
+++ b/extensions-contrib/google-extensions/src/main/java/org/apache/druid/storage/google/GoogleDataSegmentKiller.java
@@ -59,7 +59,7 @@ public void kill(DataSegment segment) throws SegmentLoadingException
       deleteIfPresent(bucket, descriptorPath);
     }
     catch (IOException e) {
-      throw new SegmentLoadingException(e, "Couldn't kill segment[%s]: [%s]", segment.getIdentifier(), e.getMessage());
+      throw new SegmentLoadingException(e, "Couldn't kill segment[%s]: [%s]", segment.getId(), e.getMessage());
     }
   }
 
diff --git a/extensions-contrib/materialized-view-maintenance/src/main/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisor.java b/extensions-contrib/materialized-view-maintenance/src/main/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisor.java
index d4e7f08d6576..488c6f81e28c 100644
--- a/extensions-contrib/materialized-view-maintenance/src/main/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisor.java
+++ b/extensions-contrib/materialized-view-maintenance/src/main/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisor.java
@@ -353,7 +353,7 @@ Pair<SortedMap<Interval, String>, Map<Interval, List<DataSegment>>> checkSegment
     // drop derivative segments which interval equals the interval in toDeleteBaseSegments 
     for (Interval interval : toDropInterval.keySet()) {
       for (DataSegment segment : derivativeSegments.get(interval)) {
-        segmentManager.removeSegment(dataSource, segment.getIdentifier());
+        segmentManager.removeSegment(segment.getId());
       }
     }
     // data of the latest interval will be built firstly.
@@ -461,7 +461,7 @@ private void clearSegments()
   {
     log.info("Clear all metadata of dataSource %s", dataSource);
     metadataStorageCoordinator.deletePendingSegments(dataSource, ALL_INTERVAL);
-    segmentManager.removeDatasource(dataSource);
+    segmentManager.removeDataSource(dataSource);
     metadataStorageCoordinator.deleteDataSourceMetadata(dataSource);
   }
   
diff --git a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTest.java b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTest.java
index 7f7c43892996..9a9aa86aade8 100644
--- a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTest.java
+++ b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTest.java
@@ -46,6 +46,7 @@
 import org.apache.druid.query.select.SelectResultValue;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -111,14 +112,14 @@ public static Iterable<Object[]> constructorFeeder() throws IOException
         Arrays.asList(
             QueryRunnerTestHelper.makeQueryRunner(
                 factory,
-                "index1",
-                new IncrementalIndexSegment(index1, "index1"),
+                SegmentId.dummy("index1"),
+                new IncrementalIndexSegment(index1, SegmentId.dummy("index1")),
                 "incremental"
             ),
             QueryRunnerTestHelper.makeQueryRunner(
                 factory,
-                "index2",
-                new QueryableIndexSegment("index2", index2),
+                SegmentId.dummy("index2"),
+                new QueryableIndexSegment(index2, SegmentId.dummy("index2")),
                 "queryable"
             )
         )
diff --git a/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentFinder.java b/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentFinder.java
index aaab1b5148a2..6f44fe8ed041 100644
--- a/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentFinder.java
+++ b/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentFinder.java
@@ -28,6 +28,7 @@
 import org.apache.druid.segment.loading.DataSegmentFinder;
 import org.apache.druid.segment.loading.SegmentLoadingException;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.LocatedFileStatus;
@@ -60,7 +61,7 @@ public HdfsDataSegmentFinder(Configuration config, ObjectMapper mapper)
   public Set<DataSegment> findSegments(String workingDirPathStr, boolean updateDescriptor)
       throws SegmentLoadingException
   {
-    final Map<String, Pair<DataSegment, Long>> timestampedSegments = new HashMap<>();
+    final Map<SegmentId, Pair<DataSegment, Long>> timestampedSegments = new HashMap<>();
     final Path workingDirPath = new Path(workingDirPathStr);
     FileSystem fs;
     try {
@@ -109,7 +110,7 @@ public Set<DataSegment> findSegments(String workingDirPathStr, boolean updateDes
 
           if (fs.exists(indexZip)) {
             final DataSegment dataSegment = mapper.readValue(fs.open(path), DataSegment.class);
-            log.info("Found segment [%s] located at [%s]", dataSegment.getIdentifier(), indexZip);
+            log.info("Found segment [%s] located at [%s]", dataSegment.getId(), indexZip);
 
             final Map<String, Object> loadSpec = dataSegment.getLoadSpec();
             final String pathWithoutScheme = indexZip.toUri().getPath();
diff --git a/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentKiller.java b/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentKiller.java
index b660ea10bfdb..aa11873fb19d 100644
--- a/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentKiller.java
+++ b/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentKiller.java
@@ -58,7 +58,7 @@ private static Path getPath(DataSegment segment)
   public void kill(DataSegment segment) throws SegmentLoadingException
   {
     final Path segmentPath = getPath(segment);
-    log.info("Killing segment[%s] mapped to path[%s]", segment.getIdentifier(), segmentPath);
+    log.info("Killing segment[%s] mapped to path[%s]", segment.getId(), segmentPath);
 
     try {
       String filename = segmentPath.getName();
diff --git a/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentPusher.java b/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentPusher.java
index cf6ceab4dcbd..54a70db8cf5f 100644
--- a/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentPusher.java
+++ b/extensions-core/hdfs-storage/src/main/java/org/apache/druid/storage/hdfs/HdfsDataSegmentPusher.java
@@ -106,7 +106,7 @@ public DataSegment push(final File inDir, final DataSegment segment, final boole
 
     log.info(
         "Copying segment[%s] to HDFS at location[%s/%s]",
-        segment.getIdentifier(),
+        segment.getId(),
         fullyQualifiedStorageDirectory.get(),
         storageDir
     );
diff --git a/extensions-core/hdfs-storage/src/test/java/org/apache/druid/segment/loading/HdfsDataSegmentFinderTest.java b/extensions-core/hdfs-storage/src/test/java/org/apache/druid/segment/loading/HdfsDataSegmentFinderTest.java
index a0b7c1894c37..6d6167a1dd64 100644
--- a/extensions-core/hdfs-storage/src/test/java/org/apache/druid/segment/loading/HdfsDataSegmentFinderTest.java
+++ b/extensions-core/hdfs-storage/src/test/java/org/apache/druid/segment/loading/HdfsDataSegmentFinderTest.java
@@ -216,17 +216,17 @@ public void testFindSegments() throws Exception
     DataSegment updatedSegment5 = null;
 
     for (DataSegment dataSegment : segments) {
-      if (dataSegment.getIdentifier().equals(SEGMENT_1.getIdentifier())) {
+      if (dataSegment.getId().equals(SEGMENT_1.getId())) {
         updatedSegment1 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_2.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_2.getId())) {
         updatedSegment2 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_3.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_3.getId())) {
         updatedSegment3 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_4_0.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_4_0.getId())) {
         updatedSegment4_0 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_4_1.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_4_1.getId())) {
         updatedSegment4_1 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_5.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_5.getId())) {
         updatedSegment5 = dataSegment;
       } else {
         Assert.fail("Unexpected segment");
diff --git a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/IncrementalPublishingKafkaIndexTaskRunner.java b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/IncrementalPublishingKafkaIndexTaskRunner.java
index e815cfa30167..c8bd7b5a89a9 100644
--- a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/IncrementalPublishingKafkaIndexTaskRunner.java
+++ b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/IncrementalPublishingKafkaIndexTaskRunner.java
@@ -23,12 +23,12 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.google.common.base.Function;
-import com.google.common.base.Joiner;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Supplier;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import com.google.common.primitives.Longs;
@@ -681,10 +681,8 @@ public void onFailure(Throwable t)
 
       for (SegmentsAndMetadata handedOff : handedOffList) {
         log.info(
-            "Handoff completed for segments[%s] with metadata[%s].",
-            Joiner.on(", ").join(
-                handedOff.getSegments().stream().map(DataSegment::getIdentifier).collect(Collectors.toList())
-            ),
+            "Handoff completed for segments %s with metadata[%s].",
+            Lists.transform(handedOff.getSegments(), DataSegment::getId),
             Preconditions.checkNotNull(handedOff.getCommitMetadata(), "commitMetadata")
         );
       }
@@ -824,11 +822,8 @@ private void publishAndRegisterHandoff(SequenceMetadata sequenceMetadata)
           public void onSuccess(SegmentsAndMetadata publishedSegmentsAndMetadata)
           {
             log.info(
-                "Published segments[%s] with metadata[%s].",
-                publishedSegmentsAndMetadata.getSegments()
-                                            .stream()
-                                            .map(DataSegment::getIdentifier)
-                                            .collect(Collectors.toList()),
+                "Published segments %s with metadata[%s].",
+                Lists.transform(publishedSegmentsAndMetadata.getSegments(), DataSegment::getId),
                 Preconditions.checkNotNull(publishedSegmentsAndMetadata.getCommitMetadata(), "commitMetadata")
             );
 
@@ -853,11 +848,8 @@ public Void apply(@Nullable SegmentsAndMetadata handoffSegmentsAndMetadata)
                   {
                     if (handoffSegmentsAndMetadata == null) {
                       log.warn(
-                          "Failed to handoff segments[%s]",
-                          publishedSegmentsAndMetadata.getSegments()
-                                                      .stream()
-                                                      .map(DataSegment::getIdentifier)
-                                                      .collect(Collectors.toList())
+                          "Failed to handoff segments %s",
+                          Lists.transform(publishedSegmentsAndMetadata.getSegments(), DataSegment::getId)
                       );
                     }
                     handoffFuture.set(handoffSegmentsAndMetadata);
diff --git a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/LegacyKafkaIndexTaskRunner.java b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/LegacyKafkaIndexTaskRunner.java
index aa50e687d438..91f96e7b7d88 100644
--- a/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/LegacyKafkaIndexTaskRunner.java
+++ b/extensions-core/kafka-indexing-service/src/main/java/org/apache/druid/indexing/kafka/LegacyKafkaIndexTaskRunner.java
@@ -25,6 +25,7 @@
 import com.google.common.base.Supplier;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import org.apache.druid.data.input.Committer;
@@ -58,7 +59,7 @@
 import org.apache.druid.segment.realtime.FireDepartmentMetrics;
 import org.apache.druid.segment.realtime.appenderator.Appenderator;
 import org.apache.druid.segment.realtime.appenderator.AppenderatorDriverAddResult;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.appenderator.SegmentsAndMetadata;
 import org.apache.druid.segment.realtime.appenderator.StreamAppenderatorDriver;
 import org.apache.druid.segment.realtime.appenderator.TransactionalSegmentPublisher;
@@ -414,7 +415,7 @@ public void run()
                                             ? Utils.nullableListOf((InputRow) null)
                                             : parser.parseBatch(ByteBuffer.wrap(valueBytes));
                 boolean isPersistRequired = false;
-                final Map<String, Set<SegmentIdentifier>> segmentsToMoveOut = new HashMap<>();
+                final Map<String, Set<SegmentIdWithShardSpec>> segmentsToMoveOut = new HashMap<>();
 
                 for (InputRow row : rows) {
                   if (row != null && task.withinMinMaxRecordTime(row)) {
@@ -529,13 +530,9 @@ public void run()
           sequenceNames.values()
       ).get();
 
-      final List<String> publishedSegments = published.getSegments()
-                                                       .stream()
-                                                       .map(DataSegment::getIdentifier)
-                                                       .collect(Collectors.toList());
-
+      String publishedSegments = Lists.transform(published.getSegments(), DataSegment::getId).toString();
       log.info(
-          "Published segments[%s] with metadata[%s].",
+          "Published segments %s with metadata[%s].",
           publishedSegments,
           Preconditions.checkNotNull(published.getCommitMetadata(), "commitMetadata")
       );
@@ -556,11 +553,11 @@ public void run()
       }
 
       if (handedOff == null) {
-        log.warn("Failed to handoff segments[%s]", publishedSegments);
+        log.warn("Failed to handoff segments %s", publishedSegments);
       } else {
         log.info(
-            "Handoff completed for segments[%s] with metadata[%s]",
-            handedOff.getSegments().stream().map(DataSegment::getIdentifier).collect(Collectors.toList()),
+            "Handoff completed for segments %s with metadata[%s]",
+            Lists.transform(handedOff.getSegments(), DataSegment::getId),
             Preconditions.checkNotNull(handedOff.getCommitMetadata(), "commitMetadata")
         );
       }
diff --git a/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentFinder.java b/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentFinder.java
index 9c6815d25e98..ee0f9c582ee8 100644
--- a/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentFinder.java
+++ b/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentFinder.java
@@ -33,6 +33,7 @@
 import org.apache.druid.segment.loading.DataSegmentFinder;
 import org.apache.druid.segment.loading.SegmentLoadingException;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -65,7 +66,7 @@ public S3DataSegmentFinder(
   @Override
   public Set<DataSegment> findSegments(String workingDirPath, boolean updateDescriptor) throws SegmentLoadingException
   {
-    final Map<String, Pair<DataSegment, Long>> timestampedSegments = new HashMap<>();
+    final Map<SegmentId, Pair<DataSegment, Long>> timestampedSegments = new HashMap<>();
 
     try {
       final Iterator<S3ObjectSummary> objectSummaryIterator = S3Utils.objectSummaryIterator(
@@ -87,7 +88,7 @@ public Set<DataSegment> findSegments(String workingDirPath, boolean updateDescri
                  S3ObjectInputStream is = indexObject.getObjectContent()) {
               final ObjectMetadata objectMetadata = indexObject.getObjectMetadata();
               final DataSegment dataSegment = jsonMapper.readValue(is, DataSegment.class);
-              log.info("Found segment [%s] located at [%s]", dataSegment.getIdentifier(), indexZip);
+              log.info("Found segment [%s] located at [%s]", dataSegment.getId(), indexZip);
 
               final Map<String, Object> loadSpec = dataSegment.getLoadSpec();
               if (!S3StorageDruidModule.SCHEME.equals(loadSpec.get("type")) ||
diff --git a/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentKiller.java b/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentKiller.java
index 512b0c5b4750..8f9331a32119 100644
--- a/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentKiller.java
+++ b/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentKiller.java
@@ -62,7 +62,7 @@ public void kill(DataSegment segment) throws SegmentLoadingException
       }
     }
     catch (AmazonServiceException e) {
-      throw new SegmentLoadingException(e, "Couldn't kill segment[%s]: [%s]", segment.getIdentifier(), e);
+      throw new SegmentLoadingException(e, "Couldn't kill segment[%s]: [%s]", segment.getId(), e);
     }
   }
 
diff --git a/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentMover.java b/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentMover.java
index ebf8792c3215..ca448b57935c 100644
--- a/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentMover.java
+++ b/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentMover.java
@@ -109,7 +109,7 @@ public boolean apply(String input)
       );
     }
     catch (AmazonServiceException e) {
-      throw new SegmentLoadingException(e, "Unable to move segment[%s]: [%s]", segment.getIdentifier(), e);
+      throw new SegmentLoadingException(e, "Unable to move segment[%s]: [%s]", segment.getId(), e);
     }
   }
 
diff --git a/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentPusher.java b/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentPusher.java
index ac773e11c8c3..f2541af4bb34 100644
--- a/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentPusher.java
+++ b/extensions-core/s3-extensions/src/main/java/org/apache/druid/storage/s3/S3DataSegmentPusher.java
@@ -90,7 +90,7 @@ public DataSegment push(final File indexFilesDir, final DataSegment inSegment, f
   {
     final String s3Path = S3Utils.constructSegmentPath(config.getBaseKey(), getStorageDir(inSegment, useUniquePath));
 
-    log.info("Copying segment[%s] to S3 at location[%s]", inSegment.getIdentifier(), s3Path);
+    log.info("Copying segment[%s] to S3 at location[%s]", inSegment.getId(), s3Path);
 
     final File zipOutFile = File.createTempFile("druid", "index.zip");
     final long indexSize = CompressionUtils.zip(indexFilesDir, zipOutFile);
diff --git a/extensions-core/s3-extensions/src/test/java/org/apache/druid/storage/s3/S3DataSegmentFinderTest.java b/extensions-core/s3-extensions/src/test/java/org/apache/druid/storage/s3/S3DataSegmentFinderTest.java
index 0902a878485d..2c47679a29d6 100644
--- a/extensions-core/s3-extensions/src/test/java/org/apache/druid/storage/s3/S3DataSegmentFinderTest.java
+++ b/extensions-core/s3-extensions/src/test/java/org/apache/druid/storage/s3/S3DataSegmentFinderTest.java
@@ -190,18 +190,18 @@ public void testFindSegments() throws Exception
     DataSegment updatedSegment4_1 = null;
 
     for (DataSegment dataSegment : segments) {
-      if (dataSegment.getIdentifier().equals(SEGMENT_1.getIdentifier())) {
+      if (dataSegment.getId().equals(SEGMENT_1.getId())) {
         updatedSegment1 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_2.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_2.getId())) {
         updatedSegment2 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_3.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_3.getId())) {
         updatedSegment3 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_4_0.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_4_0.getId())) {
         updatedSegment4_0 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_4_1.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_4_1.getId())) {
         updatedSegment4_1 = dataSegment;
       } else {
-        Assert.fail("Unexpected segment identifier : " + dataSegment.getIdentifier());
+        Assert.fail("Unexpected segment identifier : " + dataSegment.getId());
       }
     }
 
diff --git a/indexing-hadoop/src/main/java/org/apache/druid/indexer/HadoopDruidIndexerConfig.java b/indexing-hadoop/src/main/java/org/apache/druid/indexer/HadoopDruidIndexerConfig.java
index 2c41a3fc07e9..f2963bd475b8 100644
--- a/indexing-hadoop/src/main/java/org/apache/druid/indexer/HadoopDruidIndexerConfig.java
+++ b/indexing-hadoop/src/main/java/org/apache/druid/indexer/HadoopDruidIndexerConfig.java
@@ -556,7 +556,8 @@ public Path makeGroupedDataDir()
 
   public Path makeDescriptorInfoPath(DataSegment segment)
   {
-    return new Path(makeDescriptorInfoDir(), StringUtils.format("%s.json", segment.getIdentifier().replace(":", "")));
+    String fileName = StringUtils.format("%s.json", segment.getId().toString().replace(":", ""));
+    return new Path(makeDescriptorInfoDir(), fileName);
   }
 
   public void addJobProperties(Job job)
diff --git a/indexing-hadoop/src/main/java/org/apache/druid/indexer/IndexGeneratorJob.java b/indexing-hadoop/src/main/java/org/apache/druid/indexer/IndexGeneratorJob.java
index ac34c755ae95..49c28ac75104 100644
--- a/indexing-hadoop/src/main/java/org/apache/druid/indexer/IndexGeneratorJob.java
+++ b/indexing-hadoop/src/main/java/org/apache/druid/indexer/IndexGeneratorJob.java
@@ -118,7 +118,7 @@ public static List<DataSegment> getPublishedSegments(HadoopDruidIndexerConfig co
       for (FileStatus status : fs.listStatus(descriptorInfoDir)) {
         final DataSegment segment = jsonMapper.readValue(fs.open(status.getPath()), DataSegment.class);
         publishedSegmentsBuilder.add(segment);
-        log.info("Adding segment %s to the list of published segments", segment.getIdentifier());
+        log.info("Adding segment %s to the list of published segments", segment.getId());
       }
     }
     catch (FileNotFoundException e) {
diff --git a/indexing-hadoop/src/main/java/org/apache/druid/indexer/hadoop/DatasourceInputFormat.java b/indexing-hadoop/src/main/java/org/apache/druid/indexer/hadoop/DatasourceInputFormat.java
index 1f578e7de631..0937c19bd569 100644
--- a/indexing-hadoop/src/main/java/org/apache/druid/indexer/hadoop/DatasourceInputFormat.java
+++ b/indexing-hadoop/src/main/java/org/apache/druid/indexer/hadoop/DatasourceInputFormat.java
@@ -83,7 +83,7 @@ public List<InputSplit> getSplits(JobContext context) throws IOException
             i,
             segments.size(),
             dataSource,
-            segment.getSegment().getIdentifier(),
+            segment.getSegment().getId(),
             segment.getInterval()
         );
       }
diff --git a/indexing-hadoop/src/main/java/org/apache/druid/indexer/hadoop/DatasourceRecordReader.java b/indexing-hadoop/src/main/java/org/apache/druid/indexer/hadoop/DatasourceRecordReader.java
index 3ec6a71d2166..bb398b448759 100644
--- a/indexing-hadoop/src/main/java/org/apache/druid/indexer/hadoop/DatasourceRecordReader.java
+++ b/indexing-hadoop/src/main/java/org/apache/druid/indexer/hadoop/DatasourceRecordReader.java
@@ -81,7 +81,7 @@ public void initialize(InputSplit split, final TaskAttemptContext context) throw
           public WindowedStorageAdapter apply(WindowedDataSegment segment)
           {
             try {
-              logger.info("Getting storage path for segment [%s]", segment.getSegment().getIdentifier());
+              logger.info("Getting storage path for segment [%s]", segment.getSegment().getId());
               Path path = new Path(JobHelper.getURIFromSegment(segment.getSegment()));
 
               logger.info("Fetch segment files from [%s]", path);
diff --git a/indexing-hadoop/src/test/java/org/apache/druid/indexer/updater/HadoopConverterJobTest.java b/indexing-hadoop/src/test/java/org/apache/druid/indexer/updater/HadoopConverterJobTest.java
index 52d20afbe6ef..f81c02a623be 100644
--- a/indexing-hadoop/src/test/java/org/apache/druid/indexer/updater/HadoopConverterJobTest.java
+++ b/indexing-hadoop/src/test/java/org/apache/druid/indexer/updater/HadoopConverterJobTest.java
@@ -266,7 +266,7 @@ private List<DataSegment> getDataSegments(
       Thread.sleep(10);
     }
     manager.poll();
-    final ImmutableDruidDataSource druidDataSource = manager.getInventoryValue(DATASOURCE);
+    final ImmutableDruidDataSource druidDataSource = manager.getDataSource(DATASOURCE);
     manager.stop();
     return Lists.newArrayList(druidDataSource.getSegments());
   }
@@ -333,7 +333,7 @@ public MetadataSegmentManagerConfig get()
       @Override
       public int compare(DataSegment o1, DataSegment o2)
       {
-        return o1.getIdentifier().compareTo(o2.getIdentifier());
+        return o1.getId().compareTo(o2.getId());
       }
     };
     Collections.sort(
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/ActionBasedSegmentAllocator.java b/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/ActionBasedSegmentAllocator.java
index 369de529d355..40b9697cd087 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/ActionBasedSegmentAllocator.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/ActionBasedSegmentAllocator.java
@@ -22,8 +22,8 @@
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.indexing.common.actions.TaskActionClient;
 import org.apache.druid.segment.indexing.DataSchema;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.appenderator.SegmentAllocator;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
 
 import java.io.IOException;
 
@@ -45,7 +45,7 @@ public ActionBasedSegmentAllocator(
   }
 
   @Override
-  public SegmentIdentifier allocate(
+  public SegmentIdWithShardSpec allocate(
       final InputRow row,
       final String sequenceName,
       final String previousSegmentId,
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/ActionBasedUsedSegmentChecker.java b/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/ActionBasedUsedSegmentChecker.java
index 2d725f6d7d14..452dd9462b81 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/ActionBasedUsedSegmentChecker.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/ActionBasedUsedSegmentChecker.java
@@ -26,7 +26,7 @@
 import org.apache.druid.java.util.common.JodaUtils;
 import org.apache.druid.indexing.common.actions.SegmentListUsedAction;
 import org.apache.druid.indexing.common.actions.TaskActionClient;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.appenderator.UsedSegmentChecker;
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Interval;
@@ -46,11 +46,11 @@ public ActionBasedUsedSegmentChecker(TaskActionClient taskActionClient)
   }
 
   @Override
-  public Set<DataSegment> findUsedSegments(Set<SegmentIdentifier> identifiers) throws IOException
+  public Set<DataSegment> findUsedSegments(Set<SegmentIdWithShardSpec> identifiers) throws IOException
   {
     // Group by dataSource
-    final Map<String, Set<SegmentIdentifier>> identifiersByDataSource = Maps.newTreeMap();
-    for (SegmentIdentifier identifier : identifiers) {
+    final Map<String, Set<SegmentIdWithShardSpec>> identifiersByDataSource = Maps.newTreeMap();
+    for (SegmentIdWithShardSpec identifier : identifiers) {
       if (!identifiersByDataSource.containsKey(identifier.getDataSource())) {
         identifiersByDataSource.put(identifier.getDataSource(), Sets.newHashSet());
       }
@@ -59,12 +59,12 @@ public Set<DataSegment> findUsedSegments(Set<SegmentIdentifier> identifiers) thr
 
     final Set<DataSegment> retVal = Sets.newHashSet();
 
-    for (Map.Entry<String, Set<SegmentIdentifier>> entry : identifiersByDataSource.entrySet()) {
+    for (Map.Entry<String, Set<SegmentIdWithShardSpec>> entry : identifiersByDataSource.entrySet()) {
       final List<Interval> intervals = JodaUtils.condenseIntervals(
-          Iterables.transform(entry.getValue(), new Function<SegmentIdentifier, Interval>()
+          Iterables.transform(entry.getValue(), new Function<SegmentIdWithShardSpec, Interval>()
           {
             @Override
-            public Interval apply(SegmentIdentifier input)
+            public Interval apply(SegmentIdWithShardSpec input)
             {
               return input.getInterval();
             }
@@ -76,7 +76,7 @@ public Interval apply(SegmentIdentifier input)
       );
 
       for (DataSegment segment : usedSegmentsForIntervals) {
-        if (identifiers.contains(SegmentIdentifier.fromDataSegment(segment))) {
+        if (identifiers.contains(SegmentIdWithShardSpec.fromDataSegment(segment))) {
           retVal.add(segment);
         }
       }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/SegmentAllocateActionGenerator.java b/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/SegmentAllocateActionGenerator.java
index 033dddb4871b..07d3f30d4c5a 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/SegmentAllocateActionGenerator.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/appenderator/SegmentAllocateActionGenerator.java
@@ -22,19 +22,19 @@
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.indexing.common.actions.TaskAction;
 import org.apache.druid.segment.indexing.DataSchema;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 
 /**
  * This class is used in {@link ActionBasedSegmentAllocator} and expected to generate a
- * {@link TaskAction<SegmentIdentifier>} which is submitted to overlords to allocate a new segment.
- * The {@link #generate} method can return any implementation of {@link TaskAction<SegmentIdentifier>}.
+ * {@link TaskAction<  SegmentIdWithShardSpec  >} which is submitted to overlords to allocate a new segment.
+ * The {@link #generate} method can return any implementation of {@link TaskAction<  SegmentIdWithShardSpec  >}.
  *
  * @see org.apache.druid.indexing.common.actions.SegmentAllocateAction
  * @see org.apache.druid.indexing.common.actions.SurrogateAction
  */
 public interface SegmentAllocateActionGenerator
 {
-  TaskAction<SegmentIdentifier> generate(
+  TaskAction<SegmentIdWithShardSpec> generate(
       DataSchema dataSchema,
       InputRow row,
       String sequenceName,
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/SegmentAllocateAction.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/SegmentAllocateAction.java
index 26c7bb74f1d3..3b0182d3a11a 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/SegmentAllocateAction.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/actions/SegmentAllocateAction.java
@@ -33,7 +33,7 @@
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.granularity.Granularity;
 import org.apache.druid.java.util.common.logger.Logger;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
@@ -52,7 +52,7 @@
  * <p/>
  * If this action cannot acquire an appropriate lock, or if it cannot expand an existing segment set, it returns null.
  */
-public class SegmentAllocateAction implements TaskAction<SegmentIdentifier>
+public class SegmentAllocateAction implements TaskAction<SegmentIdWithShardSpec>
 {
   private static final Logger log = new Logger(SegmentAllocateAction.class);
 
@@ -132,15 +132,15 @@ public boolean isSkipSegmentLineageCheck()
   }
 
   @Override
-  public TypeReference<SegmentIdentifier> getReturnTypeReference()
+  public TypeReference<SegmentIdWithShardSpec> getReturnTypeReference()
   {
-    return new TypeReference<SegmentIdentifier>()
+    return new TypeReference<SegmentIdWithShardSpec>()
     {
     };
   }
 
   @Override
-  public SegmentIdentifier perform(
+  public SegmentIdWithShardSpec perform(
       final Task task,
       final TaskActionToolbox toolbox
   )
@@ -164,9 +164,9 @@ public SegmentIdentifier perform(
           msc.getUsedSegmentsForInterval(dataSource, rowInterval)
       );
 
-      final SegmentIdentifier identifier = usedSegmentsForRow.isEmpty() ?
-                                           tryAllocateFirstSegment(toolbox, task, rowInterval) :
-                                           tryAllocateSubsequentSegment(
+      final SegmentIdWithShardSpec identifier = usedSegmentsForRow.isEmpty() ?
+                                                tryAllocateFirstSegment(toolbox, task, rowInterval) :
+                                                tryAllocateSubsequentSegment(
                                                toolbox,
                                                task,
                                                rowInterval,
@@ -210,7 +210,7 @@ public SegmentIdentifier perform(
     }
   }
 
-  private SegmentIdentifier tryAllocateFirstSegment(TaskActionToolbox toolbox, Task task, Interval rowInterval)
+  private SegmentIdWithShardSpec tryAllocateFirstSegment(TaskActionToolbox toolbox, Task task, Interval rowInterval)
   {
     // No existing segments for this row, but there might still be nearby ones that conflict with our preferred
     // segment granularity. Try that first, and then progressively smaller ones if it fails.
@@ -220,7 +220,7 @@ private SegmentIdentifier tryAllocateFirstSegment(TaskActionToolbox toolbox, Tas
                                                    .collect(Collectors.toList());
     for (Interval tryInterval : tryIntervals) {
       if (tryInterval.contains(rowInterval)) {
-        final SegmentIdentifier identifier = tryAllocate(toolbox, task, tryInterval, rowInterval, false);
+        final SegmentIdWithShardSpec identifier = tryAllocate(toolbox, task, tryInterval, rowInterval, false);
         if (identifier != null) {
           return identifier;
         }
@@ -229,7 +229,7 @@ private SegmentIdentifier tryAllocateFirstSegment(TaskActionToolbox toolbox, Tas
     return null;
   }
 
-  private SegmentIdentifier tryAllocateSubsequentSegment(
+  private SegmentIdWithShardSpec tryAllocateSubsequentSegment(
       TaskActionToolbox toolbox,
       Task task,
       Interval rowInterval,
@@ -247,7 +247,7 @@ private SegmentIdentifier tryAllocateSubsequentSegment(
     }
   }
 
-  private SegmentIdentifier tryAllocate(
+  private SegmentIdWithShardSpec tryAllocate(
       TaskActionToolbox toolbox,
       Task task,
       Interval tryInterval,
@@ -267,7 +267,7 @@ private SegmentIdentifier tryAllocate(
     }
 
     if (lockResult.isOk()) {
-      final SegmentIdentifier identifier = toolbox.getIndexerMetadataStorageCoordinator().allocatePendingSegment(
+      final SegmentIdWithShardSpec identifier = toolbox.getIndexerMetadataStorageCoordinator().allocatePendingSegment(
           dataSource,
           sequenceName,
           previousSegmentId,
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/index/YeOldePlumberSchool.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/index/YeOldePlumberSchool.java
index 8841cf3833c0..c9c60bf0987d 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/index/YeOldePlumberSchool.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/index/YeOldePlumberSchool.java
@@ -113,7 +113,7 @@ public Plumber findPlumber(
     );
 
     // Temporary directory to hold spilled segments.
-    final File persistDir = new File(tmpSegmentDir, theSink.getSegment().getIdentifier());
+    final File persistDir = new File(tmpSegmentDir, theSink.getSegment().getId().toString());
 
     // Set of spilled segments. Will be merged at the end.
     final Set<File> spilled = Sets.newHashSet();
@@ -205,11 +205,7 @@ public void finishJob()
 
           dataSegmentPusher.push(fileToUpload, segmentToUpload, false);
 
-          log.info(
-              "Uploaded segment[%s]",
-              segmentToUpload.getIdentifier()
-          );
-
+          log.info("Uploaded segment[%s]", segmentToUpload.getId());
         }
         catch (Exception e) {
           log.warn(e, "Failed to merge and upload");
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/AppendTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/AppendTask.java
index a243d5c9798f..3e90832e2fa7 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/AppendTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/AppendTask.java
@@ -98,7 +98,7 @@ public SegmentToMergeHolder apply(PartitionChunk<DataSegment> chunkInput)
                             input.getInterval(),
                             Preconditions.checkNotNull(
                                 segments.get(segment),
-                                "File for segment %s", segment.getIdentifier()
+                                "File for segment %s", segment.getId()
                             )
                         );
                       }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/ArchiveTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/ArchiveTask.java
index 1196c7fa4847..6323cbfa808a 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/ArchiveTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/ArchiveTask.java
@@ -84,13 +84,13 @@ public TaskStatus run(TaskToolbox toolbox) throws Exception
       if (unusedSegment.getVersion().compareTo(myLock.getVersion()) > 0) {
         throw new ISE(
             "WTF?! Unused segment[%s] has version[%s] > task version[%s]",
-            unusedSegment.getIdentifier(),
+            unusedSegment.getId(),
             unusedSegment.getVersion(),
             myLock.getVersion()
         );
       }
 
-      log.info("OK to archive segment: %s", unusedSegment.getIdentifier());
+      log.info("OK to archive segment: %s", unusedSegment.getId());
     }
 
     // Move segments
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/CompactionTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/CompactionTask.java
index ea1186aa3a76..79a99652005d 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/CompactionTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/CompactionTask.java
@@ -387,7 +387,7 @@ private static DataSchema createDataSchema(
     for (Pair<QueryableIndex, DataSegment> pair : queryableIndexAndSegments) {
       final QueryableIndex index = pair.lhs;
       if (index.getMetadata() == null) {
-        throw new RE("Index metadata doesn't exist for segment[%s]", pair.rhs.getIdentifier());
+        throw new RE("Index metadata doesn't exist for segment[%s]", pair.rhs.getId());
       }
     }
     final List<AggregatorFactory[]> aggregatorFactories = queryableIndexAndSegments
@@ -449,9 +449,9 @@ private static DimensionsSpec createDimensionsSpec(List<Pair<QueryableIndex, Dat
           intervalComparator.compare(shouldBeSmaller, shouldBeLarger) <= 0,
           "QueryableIndexes are not sorted! Interval[%s] of segment[%s] is laster than interval[%s] of segment[%s]",
           shouldBeSmaller,
-          queryableIndices.get(i).rhs.getIdentifier(),
+          queryableIndices.get(i).rhs.getId(),
           shouldBeLarger,
-          queryableIndices.get(i + 1).rhs.getIdentifier()
+          queryableIndices.get(i + 1).rhs.getId()
       );
     }
 
@@ -516,7 +516,7 @@ private static List<Pair<QueryableIndex, DataSegment>> loadSegments(
       for (PartitionChunk<DataSegment> chunk : partitionHolder) {
         final DataSegment segment = chunk.getObject();
         final QueryableIndex queryableIndex = indexIO.loadIndex(
-            Preconditions.checkNotNull(segmentFileMap.get(segment), "File for segment %s", segment.getIdentifier())
+            Preconditions.checkNotNull(segmentFileMap.get(segment), "File for segment %s", segment.getId())
         );
         segments.add(Pair.of(queryableIndex, segment));
       }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/ConvertSegmentTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/ConvertSegmentTask.java
index f9dfeeaf0a8e..1bf50025ea72 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/ConvertSegmentTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/ConvertSegmentTask.java
@@ -266,12 +266,12 @@ public boolean apply(DataSegment segment)
                   } else if (force) {
                     log.info(
                         "Segment[%s] already at version[%s], forcing conversion",
-                        segment.getIdentifier(),
+                        segment.getId(),
                         segmentVersion
                     );
                     return true;
                   } else {
-                    log.info("Skipping[%s], already version[%s]", segment.getIdentifier(), segmentVersion);
+                    log.info("Skipping[%s], already version[%s]", segment.getId(), segmentVersion);
                     return false;
                   }
                 }
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/IndexTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/IndexTask.java
index 5d6bef1b859d..1e5a88062c88 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/IndexTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/IndexTask.java
@@ -25,12 +25,11 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.annotation.JsonTypeName;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.base.Joiner;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.hash.HashFunction;
 import com.google.common.hash.Hashing;
@@ -80,8 +79,8 @@
 import org.apache.druid.segment.realtime.appenderator.Appenderators;
 import org.apache.druid.segment.realtime.appenderator.BaseAppenderatorDriver;
 import org.apache.druid.segment.realtime.appenderator.BatchAppenderatorDriver;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.appenderator.SegmentAllocator;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
 import org.apache.druid.segment.realtime.appenderator.SegmentsAndMetadata;
 import org.apache.druid.segment.realtime.appenderator.TransactionalSegmentPublisher;
 import org.apache.druid.segment.realtime.firehose.ChatHandler;
@@ -882,7 +881,7 @@ dataSchema, new RealtimeIOConfig(null, null, null), null
     final SegmentAllocator segmentAllocator;
     if (isGuaranteedRollup) {
       // Overwrite mode, guaranteed rollup: segments are all known in advance and there is one per sequenceName.
-      final Map<String, SegmentIdentifier> lookup = new HashMap<>();
+      final Map<String, SegmentIdWithShardSpec> lookup = new HashMap<>();
 
       for (Map.Entry<Interval, List<ShardSpec>> entry : shardSpecs.getMap().entrySet()) {
         for (ShardSpec shardSpec : entry.getValue()) {
@@ -900,7 +899,7 @@ dataSchema, new RealtimeIOConfig(null, null, null), null
           final String version = findVersion(versions, entry.getKey());
           lookup.put(
               Appenderators.getSequenceName(entry.getKey(), version, shardSpec),
-              new SegmentIdentifier(getDataSource(), entry.getKey(), version, shardSpecForPublishing)
+              new SegmentIdWithShardSpec(getDataSource(), entry.getKey(), version, shardSpecForPublishing)
           );
         }
       }
@@ -938,7 +937,7 @@ dataSchema, new RealtimeIOConfig(null, null, null), null
         }
 
         final int partitionNum = counters.computeIfAbsent(interval, x -> new AtomicInteger()).getAndIncrement();
-        return new SegmentIdentifier(
+        return new SegmentIdWithShardSpec(
             getDataSource(),
             interval,
             findVersion(versions, interval),
@@ -1051,14 +1050,7 @@ dataSchema, new RealtimeIOConfig(null, null, null), null
             buildSegmentsMeters.getUnparseable(),
             buildSegmentsMeters.getThrownAway()
         );
-        log.info(
-            "Published segments[%s]", Joiner.on(", ").join(
-                Iterables.transform(
-                    published.getSegments(),
-                    DataSegment::getIdentifier
-                )
-            )
-        );
+        log.info("Published segments: %s", Lists.transform(published.getSegments(), DataSegment::getId));
 
         toolbox.getTaskReportFileWriter().write(getTaskCompletionReports());
         return TaskStatus.success(getId());
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/KillTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/KillTask.java
index cb723800d22b..d588038e890c 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/KillTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/KillTask.java
@@ -89,13 +89,13 @@ public TaskStatus run(TaskToolbox toolbox) throws Exception
       if (unusedSegment.getVersion().compareTo(myLock.getVersion()) > 0) {
         throw new ISE(
             "WTF?! Unused segment[%s] has version[%s] > task version[%s]",
-            unusedSegment.getIdentifier(),
+            unusedSegment.getId(),
             unusedSegment.getVersion(),
             myLock.getVersion()
         );
       }
 
-      log.info("OK to kill segment: %s", unusedSegment.getIdentifier());
+      log.info("OK to kill segment: %s", unusedSegment.getId());
     }
 
     // Kill segments
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/MergeTaskBase.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/MergeTaskBase.java
index be15b4d42aaa..cf7362763ce2 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/MergeTaskBase.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/MergeTaskBase.java
@@ -27,7 +27,6 @@
 import com.google.common.base.Preconditions;
 import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Ordering;
@@ -47,6 +46,7 @@
 import org.apache.druid.segment.IndexIO;
 import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
@@ -57,6 +57,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  */
@@ -150,21 +151,7 @@ public TaskStatus run(TaskToolbox toolbox) throws Exception
     try {
       final long startTime = System.currentTimeMillis();
 
-      log.info(
-          "Starting merge of id[%s], segments: %s",
-          getId(),
-          Lists.transform(
-              segments,
-              new Function<DataSegment, String>()
-              {
-                @Override
-                public String apply(DataSegment input)
-                {
-                  return input.getIdentifier();
-                }
-              }
-          )
-      );
+      log.info("Starting merge of id[%s], segments: %s", getId(), Lists.transform(segments, DataSegment::getId));
 
       // download segments to merge
       final Map<DataSegment, File> gettedSegments = toolbox.fetchSegments(segments);
@@ -215,24 +202,16 @@ public boolean isReady(TaskActionClient taskActionClient) throws Exception
     if (!super.isReady(taskActionClient)) {
       return false;
     } else {
-      final Function<DataSegment, String> toIdentifier = new Function<DataSegment, String>()
-      {
-        @Override
-        public String apply(DataSegment dataSegment)
-        {
-          return dataSegment.getIdentifier();
-        }
-      };
-
-      final Set<String> current = ImmutableSet.copyOf(
-          Iterables.transform(
-              taskActionClient.submit(new SegmentListUsedAction(getDataSource(), getInterval(), null)),
-              toIdentifier
-          )
-      );
-      final Set<String> requested = ImmutableSet.copyOf(Iterables.transform(segments, toIdentifier));
 
-      final Set<String> missingFromRequested = Sets.difference(current, requested);
+      final Set<SegmentId> current = taskActionClient
+          .submit(new SegmentListUsedAction(getDataSource(), getInterval(), null))
+          .stream()
+          .map(DataSegment::getId)
+          .collect(Collectors.toSet());
+
+      final Set<SegmentId> requested = segments.stream().map(DataSegment::getId).collect(Collectors.toSet());
+
+      final Set<SegmentId> missingFromRequested = Sets.difference(current, requested);
       if (!missingFromRequested.isEmpty()) {
         throw new ISE(
             "Merge is invalid: current segment(s) are not in the requested set: %s",
@@ -240,7 +219,7 @@ public String apply(DataSegment dataSegment)
         );
       }
 
-      final Set<String> missingFromCurrent = Sets.difference(requested, current);
+      final Set<SegmentId> missingFromCurrent = Sets.difference(requested, current);
       if (!missingFromCurrent.isEmpty()) {
         throw new ISE(
             "Merge is invalid: requested segment(s) are not in the current set: %s",
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/MoveTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/MoveTask.java
index ccb1dc07253b..59701d33b2a3 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/MoveTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/MoveTask.java
@@ -93,13 +93,13 @@ public TaskStatus run(TaskToolbox toolbox) throws Exception
       if (unusedSegment.getVersion().compareTo(myLock.getVersion()) > 0) {
         throw new ISE(
             "WTF?! Unused segment[%s] has version[%s] > task version[%s]",
-            unusedSegment.getIdentifier(),
+            unusedSegment.getId(),
             unusedSegment.getVersion(),
             myLock.getVersion()
         );
       }
 
-      log.info("OK to move segment: %s", unusedSegment.getIdentifier());
+      log.info("OK to move segment: %s", unusedSegment.getId());
     }
 
     // Move segments
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/RestoreTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/RestoreTask.java
index 292a309e8a6b..4e2592144f3c 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/RestoreTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/RestoreTask.java
@@ -85,13 +85,13 @@ public TaskStatus run(TaskToolbox toolbox) throws Exception
       if (unusedSegment.getVersion().compareTo(myLock.getVersion()) > 0) {
         throw new ISE(
             "WTF?! Unused segment[%s] has version[%s] > task version[%s]",
-            unusedSegment.getIdentifier(),
+            unusedSegment.getId(),
             unusedSegment.getVersion(),
             myLock.getVersion()
         );
       }
 
-      log.info("OK to restore segment: %s", unusedSegment.getIdentifier());
+      log.info("OK to restore segment: %s", unusedSegment.getId());
     }
 
     final List<DataSegment> restoredSegments = new ArrayList<>();
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexSupervisorTask.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexSupervisorTask.java
index b640c56ceb10..80532b2bbb8e 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexSupervisorTask.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexSupervisorTask.java
@@ -49,7 +49,7 @@
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.segment.indexing.granularity.GranularitySpec;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.firehose.ChatHandler;
 import org.apache.druid.segment.realtime.firehose.ChatHandlerProvider;
 import org.apache.druid.segment.realtime.firehose.ChatHandlers;
@@ -314,7 +314,7 @@ private static IndexTuningConfig convertToIndexTuningConfig(ParallelIndexTuningC
   // Internal APIs
 
   /**
-   * Allocate a new {@link SegmentIdentifier} for a request from {@link ParallelIndexSubTask}.
+   * Allocate a new {@link SegmentIdWithShardSpec} for a request from {@link ParallelIndexSubTask}.
    * The returned segmentIdentifiers have different {@code partitionNum} (thereby different {@link NumberedShardSpec})
    * per bucket interval.
    */
@@ -338,7 +338,7 @@ public Response allocateSegment(
     }
 
     try {
-      final SegmentIdentifier segmentIdentifier = allocateNewSegment(timestamp);
+      final SegmentIdWithShardSpec segmentIdentifier = allocateNewSegment(timestamp);
       return Response.ok(toolbox.getObjectMapper().writeValueAsBytes(segmentIdentifier)).build();
     }
     catch (IOException | IllegalStateException e) {
@@ -350,7 +350,7 @@ public Response allocateSegment(
   }
 
   @VisibleForTesting
-  SegmentIdentifier allocateNewSegment(DateTime timestamp) throws IOException
+  SegmentIdWithShardSpec allocateNewSegment(DateTime timestamp) throws IOException
   {
     final String dataSource = getDataSource();
     final GranularitySpec granularitySpec = getIngestionSchema().getDataSchema().getGranularitySpec();
@@ -376,7 +376,7 @@ SegmentIdentifier allocateNewSegment(DateTime timestamp) throws IOException
     }
 
     final int partitionNum = counters.increment(interval.toString(), 1);
-    return new SegmentIdentifier(
+    return new SegmentIdWithShardSpec(
         dataSource,
         interval,
         findVersion(versions, interval),
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexTaskClient.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexTaskClient.java
index eb9df2941eca..9a639d33bb57 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexTaskClient.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/ParallelIndexTaskClient.java
@@ -26,7 +26,7 @@
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.http.client.HttpClient;
 import org.apache.druid.java.util.http.client.response.FullResponseHolder;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.timeline.DataSegment;
 import org.jboss.netty.handler.codec.http.HttpMethod;
 import org.joda.time.DateTime;
@@ -57,7 +57,7 @@ String getSubtaskId()
     return subtaskId;
   }
 
-  public SegmentIdentifier allocateSegment(String supervisorTaskId, DateTime timestamp) throws IOException
+  public SegmentIdWithShardSpec allocateSegment(String supervisorTaskId, DateTime timestamp) throws IOException
   {
     final FullResponseHolder response = submitSmileRequest(
         supervisorTaskId,
@@ -77,7 +77,7 @@ public SegmentIdentifier allocateSegment(String supervisorTaskId, DateTime times
     } else {
       return deserialize(
           response.getContent(),
-          new TypeReference<SegmentIdentifier>()
+          new TypeReference<SegmentIdWithShardSpec>()
           {
           }
       );
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/SinglePhaseParallelIndexTaskRunner.java b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/SinglePhaseParallelIndexTaskRunner.java
index a6b6951809c8..9053be81b1b0 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/SinglePhaseParallelIndexTaskRunner.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/common/task/batch/parallel/SinglePhaseParallelIndexTaskRunner.java
@@ -37,7 +37,7 @@
 import org.apache.druid.indexing.common.task.batch.parallel.TaskMonitor.SubTaskCompleteEvent;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.logger.Logger;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.appenderator.TransactionalSegmentPublisher;
 import org.apache.druid.segment.realtime.appenderator.UsedSegmentChecker;
 import org.apache.druid.timeline.DataSegment;
@@ -396,11 +396,11 @@ private void publish(TaskToolbox toolbox) throws IOException
       log.info("Published segments");
     } else {
       log.info("Transaction failure while publishing segments, checking if someone else beat us to it.");
-      final Set<SegmentIdentifier> segmentsIdentifiers = segmentsMap
+      final Set<SegmentIdWithShardSpec> segmentsIdentifiers = segmentsMap
           .values()
           .stream()
           .flatMap(report -> report.getSegments().stream())
-          .map(SegmentIdentifier::fromDataSegment)
+          .map(SegmentIdWithShardSpec::fromDataSegment)
           .collect(Collectors.toSet());
       if (usedSegmentChecker.findUsedSegments(segmentsIdentifiers)
                             .equals(segmentsToPublish)) {
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/firehose/IngestSegmentFirehoseFactory.java b/indexing-service/src/main/java/org/apache/druid/indexing/firehose/IngestSegmentFirehoseFactory.java
index 779ebe0b308a..8087582ecb55 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/firehose/IngestSegmentFirehoseFactory.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/firehose/IngestSegmentFirehoseFactory.java
@@ -179,7 +179,7 @@ public WindowedStorageAdapter apply(final PartitionChunk<DataSegment> input)
                                             indexIO.loadIndex(
                                                 Preconditions.checkNotNull(
                                                     segmentFileMap.get(segment),
-                                                    "File for segment %s", segment.getIdentifier()
+                                                    "File for segment %s", segment.getId()
                                                 )
                                             )
                                         ),
diff --git a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/hrtr/WorkerHolder.java b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/hrtr/WorkerHolder.java
index c289a7c8563e..d46f28938cad 100644
--- a/indexing-service/src/main/java/org/apache/druid/indexing/overlord/hrtr/WorkerHolder.java
+++ b/indexing-service/src/main/java/org/apache/druid/indexing/overlord/hrtr/WorkerHolder.java
@@ -58,6 +58,7 @@
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
@@ -335,7 +336,7 @@ public void stop()
 
   public void waitForInitialization() throws InterruptedException
   {
-    if (!syncer.awaitInitialization(3 * syncer.getServerHttpTimeout())) {
+    if (!syncer.awaitInitialization(3 * syncer.getServerHttpTimeout(), TimeUnit.MILLISECONDS)) {
       throw new RE("Failed to sync with worker[%s].", worker.getHost());
     }
   }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/appenderator/ActionBasedUsedSegmentCheckerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/appenderator/ActionBasedUsedSegmentCheckerTest.java
index 1cb44061197f..5dcb31f98f17 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/appenderator/ActionBasedUsedSegmentCheckerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/appenderator/ActionBasedUsedSegmentCheckerTest.java
@@ -24,7 +24,7 @@
 import org.apache.druid.indexing.common.actions.SegmentListUsedAction;
 import org.apache.druid.indexing.common.actions.TaskActionClient;
 import org.apache.druid.java.util.common.Intervals;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.appenderator.UsedSegmentChecker;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.LinearShardSpec;
@@ -98,9 +98,9 @@ public void testBasic() throws IOException
     final UsedSegmentChecker checker = new ActionBasedUsedSegmentChecker(taskActionClient);
     final Set<DataSegment> segments = checker.findUsedSegments(
         ImmutableSet.of(
-            new SegmentIdentifier("foo", Intervals.of("2000/P1D"), "a", new LinearShardSpec(1)),
-            new SegmentIdentifier("foo", Intervals.of("2001/P1D"), "b", new LinearShardSpec(0)),
-            new SegmentIdentifier("bar", Intervals.of("2002/P1D"), "b", new LinearShardSpec(0))
+            new SegmentIdWithShardSpec("foo", Intervals.of("2000/P1D"), "a", new LinearShardSpec(1)),
+            new SegmentIdWithShardSpec("foo", Intervals.of("2001/P1D"), "b", new LinearShardSpec(0)),
+            new SegmentIdWithShardSpec("bar", Intervals.of("2002/P1D"), "b", new LinearShardSpec(0))
         )
     );
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentAllocateActionTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentAllocateActionTest.java
index 64bb9a86049d..1debc77f6b45 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentAllocateActionTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentAllocateActionTest.java
@@ -35,7 +35,7 @@
 import org.apache.druid.java.util.common.granularity.Granularity;
 import org.apache.druid.java.util.emitter.EmittingLogger;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.LinearShardSpec;
 import org.apache.druid.timeline.partition.NumberedShardSpec;
@@ -111,7 +111,7 @@ public void testManySegmentsSameInterval()
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(
+    final SegmentIdWithShardSpec id1 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
@@ -119,21 +119,21 @@ public void testManySegmentsSameInterval()
         "s1",
         null
     );
-    final SegmentIdentifier id2 = allocate(
+    final SegmentIdWithShardSpec id2 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
-    final SegmentIdentifier id3 = allocate(
+    final SegmentIdWithShardSpec id3 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id2.getIdentifierAsString()
+        id2.toString()
     );
 
     final TaskLock partyLock = Iterables.getOnlyElement(
@@ -143,7 +143,7 @@ public void testManySegmentsSameInterval()
 
     assertSameIdentifier(
         id1,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             partyLock.getVersion(),
@@ -152,7 +152,7 @@ public void testManySegmentsSameInterval()
     );
     assertSameIdentifier(
         id2,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             partyLock.getVersion(),
@@ -161,7 +161,7 @@ public void testManySegmentsSameInterval()
     );
     assertSameIdentifier(
         id3,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             partyLock.getVersion(),
@@ -177,7 +177,7 @@ public void testResumeSequence()
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(
+    final SegmentIdWithShardSpec id1 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
@@ -185,53 +185,53 @@ public void testResumeSequence()
         "s1",
         null
     );
-    final SegmentIdentifier id2 = allocate(
+    final SegmentIdWithShardSpec id2 = allocate(
         task,
         THE_DISTANT_FUTURE,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
-    final SegmentIdentifier id3 = allocate(
+    final SegmentIdWithShardSpec id3 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id2.getIdentifierAsString()
+        id2.toString()
     );
-    final SegmentIdentifier id4 = allocate(
+    final SegmentIdWithShardSpec id4 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
-    final SegmentIdentifier id5 = allocate(
+    final SegmentIdWithShardSpec id5 = allocate(
         task,
         THE_DISTANT_FUTURE,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
-    final SegmentIdentifier id6 = allocate(
+    final SegmentIdWithShardSpec id6 = allocate(
         task,
         THE_DISTANT_FUTURE,
         Granularities.NONE,
         Granularities.MINUTE,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
-    final SegmentIdentifier id7 = allocate(
+    final SegmentIdWithShardSpec id7 = allocate(
         task,
         THE_DISTANT_FUTURE,
         Granularities.NONE,
         Granularities.DAY,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
 
     final TaskLock partyLock = Iterables.getOnlyElement(
@@ -263,7 +263,7 @@ public boolean apply(TaskLock input)
 
     assertSameIdentifier(
         id1,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             partyLock.getVersion(),
@@ -272,7 +272,7 @@ public boolean apply(TaskLock input)
     );
     assertSameIdentifier(
         id2,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(THE_DISTANT_FUTURE),
             futureLock.getVersion(),
@@ -281,7 +281,7 @@ public boolean apply(TaskLock input)
     );
     assertSameIdentifier(
         id3,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             partyLock.getVersion(),
@@ -301,33 +301,33 @@ public void testMultipleSequences()
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.HOUR, "s1", null);
-    final SegmentIdentifier id2 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.HOUR, "s2", null);
-    final SegmentIdentifier id3 = allocate(
+    final SegmentIdWithShardSpec id1 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.HOUR, "s1", null);
+    final SegmentIdWithShardSpec id2 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.HOUR, "s2", null);
+    final SegmentIdWithShardSpec id3 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
-    final SegmentIdentifier id4 = allocate(
+    final SegmentIdWithShardSpec id4 = allocate(
         task,
         THE_DISTANT_FUTURE,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id3.getIdentifierAsString()
+        id3.toString()
     );
-    final SegmentIdentifier id5 = allocate(
+    final SegmentIdWithShardSpec id5 = allocate(
         task,
         THE_DISTANT_FUTURE,
         Granularities.NONE,
         Granularities.HOUR,
         "s2",
-        id2.getIdentifierAsString()
+        id2.toString()
     );
-    final SegmentIdentifier id6 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.HOUR, "s1", null);
+    final SegmentIdWithShardSpec id6 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.HOUR, "s1", null);
 
     final TaskLock partyLock = Iterables.getOnlyElement(
         FluentIterable.from(taskActionTestKit.getTaskLockbox().findLocksForTask(task))
@@ -358,7 +358,7 @@ public boolean apply(TaskLock input)
 
     assertSameIdentifier(
         id1,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             partyLock.getVersion(),
@@ -367,7 +367,7 @@ public boolean apply(TaskLock input)
     );
     assertSameIdentifier(
         id2,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             partyLock.getVersion(),
@@ -376,7 +376,7 @@ public boolean apply(TaskLock input)
     );
     assertSameIdentifier(
         id3,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             partyLock.getVersion(),
@@ -385,7 +385,7 @@ public boolean apply(TaskLock input)
     );
     assertSameIdentifier(
         id4,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(THE_DISTANT_FUTURE),
             futureLock.getVersion(),
@@ -394,7 +394,7 @@ public boolean apply(TaskLock input)
     );
     assertSameIdentifier(
         id5,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(THE_DISTANT_FUTURE),
             futureLock.getVersion(),
@@ -431,7 +431,7 @@ public void testAddToExistingLinearShardSpecsSameGranularity() throws Exception
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(
+    final SegmentIdWithShardSpec id1 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
@@ -439,18 +439,18 @@ public void testAddToExistingLinearShardSpecsSameGranularity() throws Exception
         "s1",
         null
     );
-    final SegmentIdentifier id2 = allocate(
+    final SegmentIdWithShardSpec id2 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
 
     assertSameIdentifier(
         id1,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             PARTY_TIME.toString(),
@@ -459,7 +459,7 @@ public void testAddToExistingLinearShardSpecsSameGranularity() throws Exception
     );
     assertSameIdentifier(
         id2,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             PARTY_TIME.toString(),
@@ -492,7 +492,7 @@ public void testAddToExistingNumberedShardSpecsSameGranularity() throws Exceptio
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(
+    final SegmentIdWithShardSpec id1 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
@@ -500,18 +500,18 @@ public void testAddToExistingNumberedShardSpecsSameGranularity() throws Exceptio
         "s1",
         null
     );
-    final SegmentIdentifier id2 = allocate(
+    final SegmentIdWithShardSpec id2 = allocate(
         task,
         PARTY_TIME,
         Granularities.NONE,
         Granularities.HOUR,
         "s1",
-        id1.getIdentifierAsString()
+        id1.toString()
     );
 
     assertSameIdentifier(
         id1,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             PARTY_TIME.toString(),
@@ -520,7 +520,7 @@ public void testAddToExistingNumberedShardSpecsSameGranularity() throws Exceptio
     );
     assertSameIdentifier(
         id2,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             PARTY_TIME.toString(),
@@ -553,11 +553,11 @@ public void testAddToExistingNumberedShardSpecsCoarserPreferredGranularity() thr
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.DAY, "s1", null);
+    final SegmentIdWithShardSpec id1 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.DAY, "s1", null);
 
     assertSameIdentifier(
         id1,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             PARTY_TIME.toString(),
@@ -590,11 +590,11 @@ public void testAddToExistingNumberedShardSpecsFinerPreferredGranularity() throw
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.MINUTE, "s1", null);
+    final SegmentIdWithShardSpec id1 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.MINUTE, "s1", null);
 
     assertSameIdentifier(
         id1,
-        new SegmentIdentifier(
+        new SegmentIdWithShardSpec(
             DATA_SOURCE,
             Granularities.HOUR.bucket(PARTY_TIME),
             PARTY_TIME.toString(),
@@ -627,7 +627,7 @@ public void testCannotAddToExistingNumberedShardSpecsWithCoarserQueryGranularity
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(task, PARTY_TIME, Granularities.DAY, Granularities.DAY, "s1", null);
+    final SegmentIdWithShardSpec id1 = allocate(task, PARTY_TIME, Granularities.DAY, Granularities.DAY, "s1", null);
 
     Assert.assertNull(id1);
   }
@@ -638,7 +638,7 @@ public void testCannotDoAnythingWithSillyQueryGranularity()
     final Task task = new NoopTask(null, null, 0, 0, null, null, null);
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(task, PARTY_TIME, Granularities.DAY, Granularities.HOUR, "s1", null);
+    final SegmentIdWithShardSpec id1 = allocate(task, PARTY_TIME, Granularities.DAY, Granularities.HOUR, "s1", null);
 
     Assert.assertNull(id1);
   }
@@ -667,7 +667,7 @@ public void testCannotAddToExistingSingleDimensionShardSpecs() throws Exception
 
     taskActionTestKit.getTaskLockbox().add(task);
 
-    final SegmentIdentifier id1 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.HOUR, "s1", null);
+    final SegmentIdWithShardSpec id1 = allocate(task, PARTY_TIME, Granularities.NONE, Granularities.HOUR, "s1", null);
 
     Assert.assertNull(id1);
   }
@@ -699,7 +699,7 @@ public void testSerde() throws Exception
     Assert.assertEquals("prev", action2.getPreviousSegmentId());
   }
 
-  private SegmentIdentifier allocate(
+  private SegmentIdWithShardSpec allocate(
       final Task task,
       final DateTime timestamp,
       final Granularity queryGranularity,
@@ -720,7 +720,7 @@ private SegmentIdentifier allocate(
     return action.perform(task, taskActionTestKit.getTaskActionToolbox());
   }
 
-  private void assertSameIdentifier(final SegmentIdentifier one, final SegmentIdentifier other)
+  private void assertSameIdentifier(final SegmentIdWithShardSpec one, final SegmentIdWithShardSpec other)
   {
     Assert.assertEquals(one, other);
     Assert.assertEquals(one.getShardSpec().getPartitionNum(), other.getShardSpec().getPartitionNum());
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentListActionsTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentListActionsTest.java
index 2e4503f4ac2d..7d5c64c2c61c 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentListActionsTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/actions/SegmentListActionsTest.java
@@ -73,9 +73,7 @@ public void setup() throws IOException
 
     expectedUsedSegments.forEach(s -> actionTestKit.getTaskLockbox().unlock(task, s.getInterval()));
 
-    expectedUnusedSegments.forEach(
-        s -> actionTestKit.getMetadataSegmentManager().removeSegment(task.getDataSource(), s.getIdentifier())
-    );
+    expectedUnusedSegments.forEach(s -> actionTestKit.getMetadataSegmentManager().removeSegment(s.getId()));
   }
 
   private DataSegment createSegment(Interval interval, String version)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/IndexTaskTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/IndexTaskTest.java
index 3e288c5d2f77..1da90037d35e 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/IndexTaskTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/IndexTaskTest.java
@@ -74,7 +74,7 @@
 import org.apache.druid.segment.indexing.granularity.UniformGranularitySpec;
 import org.apache.druid.segment.loading.DataSegmentKiller;
 import org.apache.druid.segment.loading.DataSegmentPusher;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.firehose.LocalFirehoseFactory;
 import org.apache.druid.segment.transform.ExpressionTransform;
 import org.apache.druid.segment.transform.TransformSpec;
@@ -1443,7 +1443,7 @@ public <RetType> RetType submit(TaskAction<RetType> taskAction)
           SegmentAllocateAction action = (SegmentAllocateAction) taskAction;
           Interval interval = action.getPreferredSegmentGranularity().bucket(action.getTimestamp());
           ShardSpec shardSpec = new NumberedShardSpec(segmentAllocatePartitionCounter++, 0);
-          return (RetType) new SegmentIdentifier(action.getDataSource(), interval, "latestVersion", shardSpec);
+          return (RetType) new SegmentIdWithShardSpec(action.getDataSource(), interval, "latestVersion", shardSpec);
         }
 
         return null;
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/batch/parallel/AbstractParallelIndexSupervisorTaskTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/batch/parallel/AbstractParallelIndexSupervisorTaskTest.java
index 024a5b7e2221..94c3c5ca3303 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/common/task/batch/parallel/AbstractParallelIndexSupervisorTaskTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/common/task/batch/parallel/AbstractParallelIndexSupervisorTaskTest.java
@@ -53,7 +53,7 @@
 import org.apache.druid.segment.loading.DataSegmentKiller;
 import org.apache.druid.segment.loading.LocalDataSegmentPusher;
 import org.apache.druid.segment.loading.LocalDataSegmentPusherConfig;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.segment.realtime.firehose.NoopChatHandlerProvider;
 import org.apache.druid.server.security.AllowAllAuthorizer;
 import org.apache.druid.server.security.Authorizer;
@@ -386,7 +386,7 @@ static class LocalParallelIndexTaskClient extends ParallelIndexTaskClient
     }
 
     @Override
-    public SegmentIdentifier allocateSegment(String supervisorTaskId, DateTime timestamp) throws IOException
+    public SegmentIdWithShardSpec allocateSegment(String supervisorTaskId, DateTime timestamp) throws IOException
     {
       return supervisorTask.allocateNewSegment(timestamp);
     }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/firehose/IngestSegmentFirehoseFactoryTimelineTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/firehose/IngestSegmentFirehoseFactoryTimelineTest.java
index bc42c876db7f..76f4542b4daa 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/firehose/IngestSegmentFirehoseFactoryTimelineTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/firehose/IngestSegmentFirehoseFactoryTimelineTest.java
@@ -67,6 +67,7 @@
 import org.apache.druid.segment.transform.TransformSpec;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.LinearShardSpec;
 import org.apache.commons.io.FileUtils;
 import org.easymock.EasyMock;
@@ -398,15 +399,15 @@ public TestCase(
     @Override
     public String toString()
     {
-      final List<String> segmentIdentifiers = Lists.newArrayList();
+      final List<SegmentId> segmentIds = Lists.newArrayList();
       for (DataSegment segment : segments) {
-        segmentIdentifiers.add(segment.getIdentifier());
+        segmentIds.add(segment.getId());
       }
       return "TestCase{" +
              "interval=" + interval +
              ", expectedCount=" + expectedCount +
              ", expectedSum=" + expectedSum +
-             ", segments=" + segmentIdentifiers +
+             ", segments=" + segmentIds +
              '}';
     }
   }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/test/TestIndexerMetadataStorageCoordinator.java b/indexing-service/src/test/java/org/apache/druid/indexing/test/TestIndexerMetadataStorageCoordinator.java
index 381170742ac0..6ff8eb514931 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/test/TestIndexerMetadataStorageCoordinator.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/test/TestIndexerMetadataStorageCoordinator.java
@@ -27,7 +27,7 @@
 import org.apache.druid.indexing.overlord.IndexerMetadataStorageCoordinator;
 import org.apache.druid.indexing.overlord.SegmentPublishResult;
 import org.apache.druid.java.util.common.Pair;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Interval;
 
@@ -123,7 +123,7 @@ public SegmentPublishResult announceHistoricalSegments(
   }
 
   @Override
-  public SegmentIdentifier allocatePendingSegment(
+  public SegmentIdWithShardSpec allocatePendingSegment(
       String dataSource,
       String sequenceName,
       String previousSegmentId,
diff --git a/java-util/src/main/java/org/apache/druid/java/util/common/DateTimes.java b/java-util/src/main/java/org/apache/druid/java/util/common/DateTimes.java
index 74e221cb9a25..969c01542dec 100644
--- a/java-util/src/main/java/org/apache/druid/java/util/common/DateTimes.java
+++ b/java-util/src/main/java/org/apache/druid/java/util/common/DateTimes.java
@@ -27,6 +27,7 @@
 import org.joda.time.format.ISODateTimeFormat;
 
 import java.util.TimeZone;
+import java.util.regex.Pattern;
 
 public final class DateTimes
 {
@@ -40,6 +41,16 @@ public final class DateTimes
       ISODateTimeFormat.dateTimeParser().withOffsetParsed()
   );
 
+  /**
+   * This pattern aims to match strings, produced by {@link DateTime#toString()}. It's not rigorous: it could accept
+   * some strings that couldn't be obtained by calling toString() on any {@link DateTime} object, and also it could
+   * not match some valid DateTime string. Use for heuristic purposes only.
+   */
+  public static final Pattern COMMON_DATE_TIME_PATTERN = Pattern.compile(
+      //year    month     day        hour       minute     second       millis  time zone
+      "[0-9]{4}-[01][0-9]-[0-3][0-9]T[0-2][0-9]:[0-5][0-9]:[0-5][0-9]\\.[0-9]{3}(Z|[+\\-][0-9]{2}(:[0-9]{2}))"
+  );
+
   public static DateTimeZone inferTzfromString(String tzId)
   {
     try {
diff --git a/java-util/src/main/java/org/apache/druid/java/util/common/guava/Sequence.java b/java-util/src/main/java/org/apache/druid/java/util/common/guava/Sequence.java
index 69fe1909970d..8e04f9f4cee1 100644
--- a/java-util/src/main/java/org/apache/druid/java/util/common/guava/Sequence.java
+++ b/java-util/src/main/java/org/apache/druid/java/util/common/guava/Sequence.java
@@ -81,9 +81,7 @@ default Sequence<T> limit(int limit)
     return new LimitedSequence<>(this, limit);
   }
 
-  default <R> Sequence<R> flatMap(
-      Function<? super T, ? extends Sequence<? extends R>> mapper
-  )
+  default <R> Sequence<R> flatMap(Function<? super T, ? extends Sequence<? extends R>> mapper)
   {
     return new ConcatSequence<>(this.map(mapper));
   }
diff --git a/java-util/src/test/java/org/apache/druid/java/util/common/DateTimesTest.java b/java-util/src/test/java/org/apache/druid/java/util/common/DateTimesTest.java
new file mode 100644
index 000000000000..ab99084aa2f7
--- /dev/null
+++ b/java-util/src/test/java/org/apache/druid/java/util/common/DateTimesTest.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.druid.java.util.common;
+
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DateTimesTest
+{
+
+  @Test
+  public void testCommonDateTimePattern()
+  {
+    DateTime dt1 = DateTimes.nowUtc();
+    DateTime dt2 = new DateTime(System.currentTimeMillis(), DateTimeZone.forID("IST"));
+    DateTime dt3 = new DateTime(System.currentTimeMillis(), DateTimeZone.forOffsetHoursMinutes(1, 30));
+
+    for (DateTime dt : new DateTime[] {dt1, dt2, dt3}) {
+      Assert.assertTrue(DateTimes.COMMON_DATE_TIME_PATTERN.matcher(dt.toString()).matches());
+    }
+  }
+}
diff --git a/processing/src/main/java/org/apache/druid/query/BySegmentQueryRunner.java b/processing/src/main/java/org/apache/druid/query/BySegmentQueryRunner.java
index a2ed5574f1b1..b6a74ca72703 100644
--- a/processing/src/main/java/org/apache/druid/query/BySegmentQueryRunner.java
+++ b/processing/src/main/java/org/apache/druid/query/BySegmentQueryRunner.java
@@ -21,6 +21,7 @@
 
 import org.apache.druid.java.util.common.guava.Sequence;
 import org.apache.druid.java.util.common.guava.Sequences;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTime;
 
 import java.util.Collections;
@@ -31,17 +32,13 @@
  */
 public class BySegmentQueryRunner<T> implements QueryRunner<T>
 {
-  private final String segmentIdentifier;
+  private final SegmentId segmentId;
   private final DateTime timestamp;
   private final QueryRunner<T> base;
 
-  public BySegmentQueryRunner(
-      String segmentIdentifier,
-      DateTime timestamp,
-      QueryRunner<T> base
-  )
+  public BySegmentQueryRunner(SegmentId segmentId, DateTime timestamp, QueryRunner<T> base)
   {
-    this.segmentIdentifier = segmentIdentifier;
+    this.segmentId = segmentId;
     this.timestamp = timestamp;
     this.base = base;
   }
@@ -55,11 +52,11 @@ public Sequence<T> run(final QueryPlus<T> queryPlus, Map<String, Object> respons
       final List<T> results = baseSequence.toList();
       return Sequences.simple(
           Collections.singletonList(
-              (T) new Result<BySegmentResultValueClass<T>>(
+              (T) new Result<>(
                   timestamp,
-                  new BySegmentResultValueClass<T>(
+                  new BySegmentResultValueClass<>(
                       results,
-                      segmentIdentifier,
+                      segmentId.toString(),
                       queryPlus.getQuery().getIntervals().get(0)
                   )
               )
diff --git a/processing/src/main/java/org/apache/druid/query/BySegmentResultValueClass.java b/processing/src/main/java/org/apache/druid/query/BySegmentResultValueClass.java
index d5ce01b9ead9..94241dabe64b 100644
--- a/processing/src/main/java/org/apache/druid/query/BySegmentResultValueClass.java
+++ b/processing/src/main/java/org/apache/druid/query/BySegmentResultValueClass.java
@@ -31,6 +31,15 @@
 public class BySegmentResultValueClass<T> implements BySegmentResultValue<T>
 {
   private final List<T> results;
+  /**
+   * Segment id is stored as a String rather than {@link org.apache.druid.timeline.SegmentId}, because when a
+   * BySegmentResultValueClass object is sent across Druid nodes, on the reciever (deserialization) side it's impossible
+   * to unambiguously convert a segment id string (as transmitted in the JSON format) back into a {@code SegmentId}
+   * object ({@link org.apache.druid.timeline.SegmentId#tryParse} javadoc explains that ambiguities in details). It
+   * would be fine to have the type of this field of Object, setting it to {@code SegmentId} on the sender side and
+   * remaining as a String on the reciever side, but it's even less type-safe than always storing the segment id as
+   * a String.
+   */
   private final String segmentId;
   private final Interval interval;
 
diff --git a/processing/src/main/java/org/apache/druid/query/FinalizeResultsQueryRunner.java b/processing/src/main/java/org/apache/druid/query/FinalizeResultsQueryRunner.java
index df1d27e06dbc..db006400a58a 100644
--- a/processing/src/main/java/org/apache/druid/query/FinalizeResultsQueryRunner.java
+++ b/processing/src/main/java/org/apache/druid/query/FinalizeResultsQueryRunner.java
@@ -85,7 +85,7 @@ public T apply(T input)
 
           BySegmentResultValue<T> resultsClass = result.getValue();
 
-          return (T) new Result<BySegmentResultValueClass>(
+          return (T) new Result<>(
               result.getTimestamp(),
               new BySegmentResultValueClass(
                   Lists.transform(resultsClass.getResults(), baseFinalizer),
diff --git a/processing/src/main/java/org/apache/druid/query/Result.java b/processing/src/main/java/org/apache/druid/query/Result.java
index f68ba41819ef..c1ec3a3a5ba9 100644
--- a/processing/src/main/java/org/apache/druid/query/Result.java
+++ b/processing/src/main/java/org/apache/druid/query/Result.java
@@ -37,10 +37,7 @@ public class Result<T> implements Comparable<Result<T>>
   private final T value;
 
   @JsonCreator
-  public Result(
-      @JsonProperty("timestamp") DateTime timestamp,
-      @JsonProperty("result") T value
-  )
+  public Result(@JsonProperty("timestamp") DateTime timestamp, @JsonProperty("result") T value)
   {
     this.timestamp = timestamp;
     this.value = value;
diff --git a/processing/src/main/java/org/apache/druid/query/metadata/SegmentMetadataQueryRunnerFactory.java b/processing/src/main/java/org/apache/druid/query/metadata/SegmentMetadataQueryRunnerFactory.java
index 2b925b3e4336..d50fed908283 100644
--- a/processing/src/main/java/org/apache/druid/query/metadata/SegmentMetadataQueryRunnerFactory.java
+++ b/processing/src/main/java/org/apache/druid/query/metadata/SegmentMetadataQueryRunnerFactory.java
@@ -165,7 +165,7 @@ public Sequence<SegmentAnalysis> run(QueryPlus<SegmentAnalysis> inQ, Map<String,
         return Sequences.simple(
             Collections.singletonList(
                 new SegmentAnalysis(
-                    segment.getIdentifier(),
+                    segment.getId().toString(),
                     retIntervals,
                     columns,
                     totalSize,
diff --git a/processing/src/main/java/org/apache/druid/query/metadata/metadata/SegmentAnalysis.java b/processing/src/main/java/org/apache/druid/query/metadata/metadata/SegmentAnalysis.java
index f4f6e0419689..9cc805ec2218 100644
--- a/processing/src/main/java/org/apache/druid/query/metadata/metadata/SegmentAnalysis.java
+++ b/processing/src/main/java/org/apache/druid/query/metadata/metadata/SegmentAnalysis.java
@@ -32,6 +32,14 @@
 
 public class SegmentAnalysis implements Comparable<SegmentAnalysis>
 {
+  /**
+   * Segment id is stored as a String rather than {@link org.apache.druid.timeline.SegmentId}, because when a
+   * SegmentAnalysis object is sent across Druid nodes, on the reciever (deserialization) side it's impossible to
+   * unambiguously convert a segment id string (as transmitted in the JSON format) back into a {@code SegmentId} object
+   * ({@link org.apache.druid.timeline.SegmentId#tryParse} javadoc explains that ambiguities in details). It would be
+   * fine to have the type of this field of Object, setting it to {@code SegmentId} on the sender side and remaining as
+   * a String on the reciever side, but it's even less type-safe than always storing the segment id as a String.
+   */
   private final String id;
   private final List<Interval> interval;
   private final Map<String, ColumnAnalysis> columns;
diff --git a/processing/src/main/java/org/apache/druid/query/scan/ScanQueryEngine.java b/processing/src/main/java/org/apache/druid/query/scan/ScanQueryEngine.java
index 06c48063a7cd..db911610025c 100644
--- a/processing/src/main/java/org/apache/druid/query/scan/ScanQueryEngine.java
+++ b/processing/src/main/java/org/apache/druid/query/scan/ScanQueryEngine.java
@@ -40,6 +40,7 @@
 import org.apache.druid.segment.VirtualColumn;
 import org.apache.druid.segment.column.Column;
 import org.apache.druid.segment.filter.Filters;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 import java.util.ArrayList;
@@ -115,7 +116,7 @@ public Sequence<ScanResultValue> process(
     final List<Interval> intervals = query.getQuerySegmentSpec().getIntervals();
     Preconditions.checkArgument(intervals.size() == 1, "Can only handle a single interval, got[%s]", intervals);
 
-    final String segmentId = segment.getIdentifier();
+    final SegmentId segmentId = segment.getId();
 
     final Filter filter = Filters.convertToCNFFromQueryContext(query, Filters.toFilter(query.getFilter()));
 
@@ -196,7 +197,7 @@ public ScanResultValue next()
                                   timeoutAt - (System.currentTimeMillis() - start)
                               );
                             }
-                            return new ScanResultValue(segmentId, allColumns, events);
+                            return new ScanResultValue(segmentId.toString(), allColumns, events);
                           }
 
                           @Override
diff --git a/processing/src/main/java/org/apache/druid/query/scan/ScanResultValue.java b/processing/src/main/java/org/apache/druid/query/scan/ScanResultValue.java
index 6fa38250478d..686b117b3b89 100644
--- a/processing/src/main/java/org/apache/druid/query/scan/ScanResultValue.java
+++ b/processing/src/main/java/org/apache/druid/query/scan/ScanResultValue.java
@@ -25,6 +25,14 @@
 
 public class ScanResultValue implements Comparable<ScanResultValue>
 {
+  /**
+   * Segment id is stored as a String rather than {@link org.apache.druid.timeline.SegmentId}, because when a result
+   * is sent from Historical to Broker server, on the deserialization side (Broker) it's impossible to unambiguously
+   * convert a segment id string (as transmitted in the JSON format) back into a {@code SegmentId} object ({@link
+   * org.apache.druid.timeline.SegmentId#tryParse} javadoc explains that ambiguities in details). It would be fine to
+   * have the type of this field of Object, setting it to {@code SegmentId} on the Historical side and remaining as a
+   * String on the Broker side, but it's even less type-safe than always storing the segment id as a String.
+   */
   private final String segmentId;
   private final List<String> columns;
   private final Object events;
diff --git a/processing/src/main/java/org/apache/druid/query/select/SelectQueryEngine.java b/processing/src/main/java/org/apache/druid/query/select/SelectQueryEngine.java
index a61067583244..1590d4970226 100644
--- a/processing/src/main/java/org/apache/druid/query/select/SelectQueryEngine.java
+++ b/processing/src/main/java/org/apache/druid/query/select/SelectQueryEngine.java
@@ -21,7 +21,6 @@
 
 import com.google.common.base.Function;
 import com.google.common.base.Preconditions;
-import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import org.apache.druid.java.util.common.DateTimes;
@@ -51,7 +50,6 @@
 import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.data.IndexedInts;
 import org.apache.druid.segment.filter.Filters;
-import org.apache.druid.timeline.DataSegmentUtils;
 import org.joda.time.Interval;
 
 import java.util.ArrayList;
@@ -192,8 +190,11 @@ public Sequence<Result<SelectResultValue>> process(final SelectQuery query, fina
       );
     }
 
-    // at the point where this code is called, only one datasource should exist.
-    String dataSource = Iterables.getOnlyElement(query.getDataSource().getNames());
+    Preconditions.checkArgument(
+        query.getDataSource().getNames().size() == 1,
+        "At the point where this code is called, only one data source should exist. Data sources: %s",
+        query.getDataSource().getNames()
+    );
 
     final Iterable<DimensionSpec> dims;
     if (query.getDimensions() == null || query.getDimensions().isEmpty()) {
@@ -212,7 +213,7 @@ public Sequence<Result<SelectResultValue>> process(final SelectQuery query, fina
     Preconditions.checkArgument(intervals.size() == 1, "Can only handle a single interval, got[%s]", intervals);
 
     // should be rewritten with given interval
-    final String segmentId = DataSegmentUtils.withInterval(dataSource, segment.getIdentifier(), intervals.get(0));
+    final String segmentId = segment.getId().withInterval(intervals.get(0)).toString();
 
     final Filter filter = Filters.convertToCNFFromQueryContext(query, Filters.toFilter(query.getDimensionsFilter()));
 
diff --git a/processing/src/main/java/org/apache/druid/query/select/SelectQueryQueryToolChest.java b/processing/src/main/java/org/apache/druid/query/select/SelectQueryQueryToolChest.java
index ad2ae5563e57..d9e8577fbba5 100644
--- a/processing/src/main/java/org/apache/druid/query/select/SelectQueryQueryToolChest.java
+++ b/processing/src/main/java/org/apache/druid/query/select/SelectQueryQueryToolChest.java
@@ -24,7 +24,6 @@
 import com.google.common.base.Function;
 import com.google.common.base.Functions;
 import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
 import com.google.common.base.Supplier;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
@@ -49,7 +48,7 @@
 import org.apache.druid.query.aggregation.MetricManipulationFn;
 import org.apache.druid.query.dimension.DimensionSpec;
 import org.apache.druid.query.filter.DimFilter;
-import org.apache.druid.timeline.DataSegmentUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.LogicalSegment;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
@@ -366,44 +365,33 @@ public <T extends LogicalSegment> List<T> filterSegments(SelectQuery query, List
 
     final Granularity granularity = query.getGranularity();
 
+    TreeMap<Long, Long> granularThresholds = Maps.newTreeMap();
+
     // A paged select query using a UnionDataSource will return pagingIdentifiers from segments in more than one
     // dataSource which confuses subsequent queries and causes a failure. To avoid this, filter only the paging keys
     // that are applicable to this dataSource so that each dataSource in a union query gets the appropriate keys.
-    final Iterable<String> filteredPagingKeys = Iterables.filter(
-        paging.keySet(), new Predicate<String>()
-        {
-          @Override
-          public boolean apply(String input)
-          {
-            return DataSegmentUtils.valueOf(dataSource, input) != null;
+    paging
+        .keySet()
+        .stream()
+        .filter(identifier -> SegmentId.tryParse(dataSource, identifier) != null)
+        .map(SegmentId.makeIntervalExtractor(dataSource))
+        .sorted(query.isDescending() ? Comparators.intervalsByEndThenStart()
+                                     : Comparators.intervalsByStartThenEnd())
+        .forEach(interval -> {
+          if (query.isDescending()) {
+            long granularEnd = granularity.bucketStart(interval.getEnd()).getMillis();
+            Long currentEnd = granularThresholds.get(granularEnd);
+            if (currentEnd == null || interval.getEndMillis() > currentEnd) {
+              granularThresholds.put(granularEnd, interval.getEndMillis());
+            }
+          } else {
+            long granularStart = granularity.bucketStart(interval.getStart()).getMillis();
+            Long currentStart = granularThresholds.get(granularStart);
+            if (currentStart == null || interval.getStartMillis() < currentStart) {
+              granularThresholds.put(granularStart, interval.getStartMillis());
+            }
           }
-        }
-    );
-
-    List<Interval> intervals = Lists.newArrayList(
-        Iterables.transform(filteredPagingKeys, DataSegmentUtils.INTERVAL_EXTRACTOR(dataSource))
-    );
-    Collections.sort(
-        intervals, query.isDescending() ? Comparators.intervalsByEndThenStart()
-                                        : Comparators.intervalsByStartThenEnd()
-    );
-
-    TreeMap<Long, Long> granularThresholds = Maps.newTreeMap();
-    for (Interval interval : intervals) {
-      if (query.isDescending()) {
-        long granularEnd = granularity.bucketStart(interval.getEnd()).getMillis();
-        Long currentEnd = granularThresholds.get(granularEnd);
-        if (currentEnd == null || interval.getEndMillis() > currentEnd) {
-          granularThresholds.put(granularEnd, interval.getEndMillis());
-        }
-      } else {
-        long granularStart = granularity.bucketStart(interval.getStart()).getMillis();
-        Long currentStart = granularThresholds.get(granularStart);
-        if (currentStart == null || interval.getStartMillis() < currentStart) {
-          granularThresholds.put(granularStart, interval.getStartMillis());
-        }
-      }
-    }
+        });
 
     List<T> queryIntervals = Lists.newArrayList(segments);
 
diff --git a/processing/src/main/java/org/apache/druid/query/topn/TopNResultValue.java b/processing/src/main/java/org/apache/druid/query/topn/TopNResultValue.java
index 84d97efa2f51..ed26c8aeda85 100644
--- a/processing/src/main/java/org/apache/druid/query/topn/TopNResultValue.java
+++ b/processing/src/main/java/org/apache/druid/query/topn/TopNResultValue.java
@@ -37,9 +37,7 @@ public class TopNResultValue implements Iterable<DimensionAndMetricValueExtracto
   private final List<DimensionAndMetricValueExtractor> value;
 
   @JsonCreator
-  public TopNResultValue(
-      List<?> value
-  )
+  public TopNResultValue(List<?> value)
   {
     this.value = (value == null) ? Lists.newArrayList() : Lists.transform(
         value,
diff --git a/processing/src/main/java/org/apache/druid/segment/IncrementalIndexSegment.java b/processing/src/main/java/org/apache/druid/segment/IncrementalIndexSegment.java
index f48adc6e623b..683106cf3871 100644
--- a/processing/src/main/java/org/apache/druid/segment/IncrementalIndexSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/IncrementalIndexSegment.java
@@ -21,6 +21,7 @@
 
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexStorageAdapter;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 /**
@@ -28,21 +29,18 @@
 public class IncrementalIndexSegment extends AbstractSegment
 {
   private final IncrementalIndex index;
-  private final String segmentIdentifier;
+  private final SegmentId segmentId;
 
-  public IncrementalIndexSegment(
-      IncrementalIndex index,
-      String segmentIdentifier
-  )
+  public IncrementalIndexSegment(IncrementalIndex index, SegmentId segmentId)
   {
     this.index = index;
-    this.segmentIdentifier = segmentIdentifier;
+    this.segmentId = segmentId;
   }
 
   @Override
-  public String getIdentifier()
+  public SegmentId getId()
   {
-    return segmentIdentifier;
+    return segmentId;
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/segment/QueryableIndexSegment.java b/processing/src/main/java/org/apache/druid/segment/QueryableIndexSegment.java
index 40d89c7736ed..8f681781ac10 100644
--- a/processing/src/main/java/org/apache/druid/segment/QueryableIndexSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/QueryableIndexSegment.java
@@ -19,25 +19,26 @@
 
 package org.apache.druid.segment;
 
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 /**
-*/
+ */
 public class QueryableIndexSegment extends AbstractSegment
 {
   private final QueryableIndex index;
-  private final String identifier;
+  private final SegmentId segmentId;
 
-  public QueryableIndexSegment(final String segmentIdentifier, QueryableIndex index)
+  public QueryableIndexSegment(QueryableIndex index, final SegmentId segmentId)
   {
     this.index = index;
-    identifier = segmentIdentifier;
+    this.segmentId = segmentId;
   }
 
   @Override
-  public String getIdentifier()
+  public SegmentId getId()
   {
-    return identifier;
+    return segmentId;
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
index 7add08fa7bdf..4f27a4f33943 100644
--- a/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
+++ b/processing/src/main/java/org/apache/druid/segment/ReferenceCountingSegment.java
@@ -21,6 +21,7 @@
 
 import com.google.common.base.Preconditions;
 import org.apache.druid.java.util.emitter.EmittingLogger;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 import java.io.Closeable;
@@ -51,7 +52,7 @@ protected boolean onAdvance(int phase, int registeredParties)
       }
       catch (Exception e) {
         try {
-          log.error(e, "Exception while closing segment[%s]", baseSegment.getIdentifier());
+          log.error(e, "Exception while closing segment[%s]", baseSegment.getId());
         }
         catch (Exception e2) {
           // ignore
@@ -83,9 +84,9 @@ public boolean isClosed()
   }
 
   @Override
-  public String getIdentifier()
+  public SegmentId getId()
   {
-    return !isClosed() ? baseSegment.getIdentifier() : null;
+    return !isClosed() ? baseSegment.getId() : null;
   }
 
   @Override
diff --git a/processing/src/main/java/org/apache/druid/segment/Segment.java b/processing/src/main/java/org/apache/druid/segment/Segment.java
index 3f7395430c14..f75f6a210050 100644
--- a/processing/src/main/java/org/apache/druid/segment/Segment.java
+++ b/processing/src/main/java/org/apache/druid/segment/Segment.java
@@ -20,16 +20,20 @@
 package org.apache.druid.segment;
 
 import org.apache.druid.guice.annotations.PublicApi;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 import java.io.Closeable;
 
 /**
+ * The difference between this class and {@link org.apache.druid.timeline.DataSegment} is that {@link
+ * org.apache.druid.timeline.DataSegment} contains the segment metadata only, while this class represents the actual
+ * body of segment data, queryable.
  */
 @PublicApi
 public interface Segment extends Closeable
 {
-  String getIdentifier();
+  SegmentId getId();
   Interval getDataInterval();
   QueryableIndex asQueryableIndex();
   StorageAdapter asStorageAdapter();
diff --git a/processing/src/main/java/org/apache/druid/segment/loading/MMappedQueryableSegmentizerFactory.java b/processing/src/main/java/org/apache/druid/segment/loading/MMappedQueryableSegmentizerFactory.java
index 9a1abffa4b7c..d3cd9db84335 100644
--- a/processing/src/main/java/org/apache/druid/segment/loading/MMappedQueryableSegmentizerFactory.java
+++ b/processing/src/main/java/org/apache/druid/segment/loading/MMappedQueryableSegmentizerFactory.java
@@ -45,7 +45,7 @@ public MMappedQueryableSegmentizerFactory(@JacksonInject IndexIO indexIO)
   public Segment factorize(DataSegment dataSegment, File parentDir) throws SegmentLoadingException
   {
     try {
-      return new QueryableIndexSegment(dataSegment.getIdentifier(), indexIO.loadIndex(parentDir));
+      return new QueryableIndexSegment(indexIO.loadIndex(parentDir), dataSegment.getId());
     }
     catch (IOException e) {
       throw new SegmentLoadingException(e, "%s", e.getMessage());
diff --git a/processing/src/test/java/org/apache/druid/collections/bitmap/BitmapBenchmark.java b/processing/src/test/java/org/apache/druid/collections/bitmap/BitmapBenchmark.java
index 2c34deac7e5e..cdb047e3f892 100644
--- a/processing/src/test/java/org/apache/druid/collections/bitmap/BitmapBenchmark.java
+++ b/processing/src/test/java/org/apache/druid/collections/bitmap/BitmapBenchmark.java
@@ -100,9 +100,9 @@ protected static void reset()
 
   protected static void printSizeStats(double density, String name)
   {
-    System.out.println("");
+    System.out.println();
     System.out.println("## " + name);
-    System.out.println("");
+    System.out.println();
     System.out.printf(Locale.ENGLISH, " d = %06.5f | Concise | Roaring%n", density);
     System.out.println("-------------|---------|---------");
     System.out.printf(Locale.ENGLISH, "Count        |   %5d |   %5d %n", conciseCount, roaringCount);
@@ -113,7 +113,7 @@ protected static void printSizeStats(double density, String name)
         totalRoaringBytes / roaringCount
     );
     System.out.println("-------------|---------|---------");
-    System.out.println("");
+    System.out.println();
     System.out.flush();
   }
 
diff --git a/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java b/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
index 5e1283f1b6d8..49ef192703e3 100644
--- a/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
@@ -57,6 +57,7 @@
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.segment.incremental.IndexSizeExceededException;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 import org.junit.After;
 import org.junit.Assert;
@@ -115,7 +116,7 @@ private ScanQuery.ScanQueryBuilder newTestQuery()
   private static final String DIM_NAME = "testDimName";
   private static final String DIM_VALUE = "testDimValue";
   private static final String DIM_FLOAT_NAME = "testDimFloatName";
-  private static final String SEGMENT_ID = "segmentId";
+  private static final SegmentId SEGMENT_ID = SegmentId.dummy("segmentId");
   private static final Interval INTERVAL = Intervals.of("2011-01-13T00:00:00.000Z/2011-01-22T00:00:00.001Z");
 
   private static final InputRowParser<Map<String, Object>> ROW_PARSER = new MapInputRowParser(
@@ -249,7 +250,7 @@ public void testMetaDataAnalysis()
     QueryRunner runner = QueryRunnerTestHelper.makeQueryRunner(
         METADATA_QR_FACTORY,
         SEGMENT_ID,
-        new QueryableIndexSegment("segmentId", index),
+        new QueryableIndexSegment(index, SEGMENT_ID),
         null
     );
 
@@ -282,7 +283,7 @@ public void testSelectValues()
     QueryRunner runner = QueryRunnerTestHelper.makeQueryRunner(
         SCAN_QUERY_RUNNER_FACTORY,
         SEGMENT_ID,
-        new QueryableIndexSegment("segmentId", index),
+        new QueryableIndexSegment(index, SEGMENT_ID),
         null
     );
 
@@ -295,7 +296,7 @@ public void testSelectValues()
     Iterable<ScanResultValue> results = runner.run(QueryPlus.wrap(query), context).toList();
 
     ScanResultValue expectedScanResult = new ScanResultValue(
-        SEGMENT_ID,
+        SEGMENT_ID.toString(),
         ImmutableList.of(TIME_COLUMN, DIM_NAME, DIM_FLOAT_NAME),
         getStreamOfEvents().collect(Collectors.toList())
     );
diff --git a/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java b/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
index f1987267854e..0bb120242e96 100644
--- a/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
+++ b/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
@@ -61,6 +61,7 @@
 import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
 import org.apache.druid.segment.writeout.TmpFileSegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -168,8 +169,8 @@ public void testGroupByNoFilter()
 
     Sequence<Row> result = helper.runQueryOnSegmentsObjs(
         ImmutableList.of(
-            new QueryableIndexSegment("sid1", queryableIndex),
-            new IncrementalIndexSegment(incrementalIndex, "sid2")
+            new QueryableIndexSegment(queryableIndex, SegmentId.dummy("sid1")),
+            new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("sid2"))
         ),
         query
     );
@@ -203,8 +204,8 @@ public void testGroupByWithDimFilter()
 
     Sequence<Row> result = helper.runQueryOnSegmentsObjs(
         ImmutableList.of(
-            new QueryableIndexSegment("sid1", queryableIndex),
-            new IncrementalIndexSegment(incrementalIndex, "sid2")
+            new QueryableIndexSegment(queryableIndex, SegmentId.dummy("sid1")),
+            new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("sid2"))
         ),
         query
     );
@@ -235,8 +236,8 @@ public void testGroupByWithDimFilterAndWithFilteredDimSpec()
 
     Sequence<Row> result = helper.runQueryOnSegmentsObjs(
         ImmutableList.of(
-            new QueryableIndexSegment("sid1", queryableIndex),
-            new IncrementalIndexSegment(incrementalIndex, "sid2")
+            new QueryableIndexSegment(queryableIndex, SegmentId.dummy("sid1")),
+            new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("sid2"))
         ),
         query
     );
@@ -276,7 +277,7 @@ public void testTopNWithDimFilterAndWithFilteredDimSpec()
       );
       QueryRunner<Result<TopNResultValue>> runner = QueryRunnerTestHelper.makeQueryRunner(
           factory,
-          new QueryableIndexSegment("sid1", queryableIndex),
+          new QueryableIndexSegment(queryableIndex, SegmentId.dummy("sid1")),
           null
       );
       Map<String, Object> context = Maps.newHashMap();
diff --git a/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java b/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
index 14e7af3bd87a..e72f68124e40 100644
--- a/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
+++ b/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
@@ -60,6 +60,7 @@
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.incremental.IncrementalIndex;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.joda.time.DateTime;
@@ -82,7 +83,7 @@ public class QueryRunnerTestHelper
 
   public static final QueryWatcher NOOP_QUERYWATCHER = (query, future) -> {};
 
-  public static final String segmentId = "testSegment";
+  public static final SegmentId segmentId = SegmentId.dummy("testSegment");
   public static final String dataSource = "testing";
   public static final UnionDataSource unionDataSource = new UnionDataSource(
       Lists.transform(
@@ -345,15 +346,15 @@ public static <T, QueryType extends Query<T>> List<QueryRunner<T>> makeQueryRunn
     final QueryableIndex noRollupMMappedTestIndex = TestIndex.getNoRollupMMappedTestIndex();
     final QueryableIndex mergedRealtimeIndex = TestIndex.mergedRealtimeIndex();
     return ImmutableList.of(
-        makeQueryRunner(factory, new IncrementalIndexSegment(rtIndex, segmentId), "rtIndex"),
+        makeQueryRunner(factory, new IncrementalIndexSegment(rtIndex, segmentId), ("rtIndex")),
         makeQueryRunner(factory, new IncrementalIndexSegment(noRollupRtIndex, segmentId), "noRollupRtIndex"),
-        makeQueryRunner(factory, new QueryableIndexSegment(segmentId, mMappedTestIndex), "mMappedTestIndex"),
+        makeQueryRunner(factory, new QueryableIndexSegment(mMappedTestIndex, segmentId), "mMappedTestIndex"),
         makeQueryRunner(
             factory,
-            new QueryableIndexSegment(segmentId, noRollupMMappedTestIndex),
+            new QueryableIndexSegment(noRollupMMappedTestIndex, segmentId),
             "noRollupMMappedTestIndex"
         ),
-        makeQueryRunner(factory, new QueryableIndexSegment(segmentId, mergedRealtimeIndex), "mergedRealtimeIndex")
+        makeQueryRunner(factory, new QueryableIndexSegment(mergedRealtimeIndex, segmentId), "mergedRealtimeIndex")
     );
   }
 
@@ -368,10 +369,10 @@ public static Collection<?> makeUnionQueryRunners(
 
     return Arrays.asList(
         makeUnionQueryRunner(factory, new IncrementalIndexSegment(rtIndex, segmentId), "rtIndex"),
-        makeUnionQueryRunner(factory, new QueryableIndexSegment(segmentId, mMappedTestIndex), "mMappedTestIndex"),
+        makeUnionQueryRunner(factory, new QueryableIndexSegment(mMappedTestIndex, segmentId), "mMappedTestIndex"),
         makeUnionQueryRunner(
             factory,
-            new QueryableIndexSegment(segmentId, mergedRealtimeIndex),
+            new QueryableIndexSegment(mergedRealtimeIndex, segmentId),
             "mergedRealtimeIndex"
         )
     );
@@ -402,14 +403,15 @@ public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner(
 
   public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner(
       QueryRunnerFactory<T, QueryType> factory,
-      String segmentId,
+      SegmentId segmentId,
       Segment adapter,
       final String runnerName
   )
   {
     return new FinalizeResultsQueryRunner<T>(
         new BySegmentQueryRunner<T>(
-            segmentId, adapter.getDataInterval().getStart(),
+            segmentId,
+            adapter.getDataInterval().getStart(),
             factory.createRunner(adapter)
         ),
         (QueryToolChest<T, Query<T>>) factory.getToolchest()
diff --git a/processing/src/test/java/org/apache/druid/query/SchemaEvolutionTest.java b/processing/src/test/java/org/apache/druid/query/SchemaEvolutionTest.java
index f051d7105324..b19ed62ac494 100644
--- a/processing/src/test/java/org/apache/druid/query/SchemaEvolutionTest.java
+++ b/processing/src/test/java/org/apache/druid/query/SchemaEvolutionTest.java
@@ -19,7 +19,6 @@
 
 package org.apache.druid.query;
 
-import com.google.common.base.Function;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
@@ -50,6 +49,7 @@
 import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -110,14 +110,7 @@ public static <T, QueryType extends Query<T>> List<T> runQuery(
                 FunctionalIterable
                     .create(indexes)
                     .transform(
-                        new Function<QueryableIndex, QueryRunner<T>>()
-                        {
-                          @Override
-                          public QueryRunner<T> apply(final QueryableIndex index)
-                          {
-                            return factory.createRunner(new QueryableIndexSegment("xxx", index));
-                          }
-                        }
+                        index -> factory.createRunner(new QueryableIndexSegment(index, SegmentId.dummy("xxx")))
                     )
             )
         ),
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/AggregationTestHelper.java b/processing/src/test/java/org/apache/druid/query/aggregation/AggregationTestHelper.java
index 5855bb98a743..30c48efbe267 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/AggregationTestHelper.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/AggregationTestHelper.java
@@ -83,6 +83,7 @@
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.io.LineIterator;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.rules.TemporaryFolder;
 
 import java.io.Closeable;
@@ -585,7 +586,7 @@ public Sequence<Row> runQueryOnSegments(final List<File> segmentDirs, final Quer
           public Segment apply(File segmentDir)
           {
             try {
-              return new QueryableIndexSegment("", indexIO.loadIndex(segmentDir));
+              return new QueryableIndexSegment(indexIO.loadIndex(segmentDir), SegmentId.dummy(""));
             }
             catch (IOException ex) {
               throw Throwables.propagate(ex);
diff --git a/processing/src/test/java/org/apache/druid/query/datasourcemetadata/DataSourceMetadataQueryTest.java b/processing/src/test/java/org/apache/druid/query/datasourcemetadata/DataSourceMetadataQueryTest.java
index b6fad6066c6c..28bcb56b6366 100644
--- a/processing/src/test/java/org/apache/druid/query/datasourcemetadata/DataSourceMetadataQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/datasourcemetadata/DataSourceMetadataQueryTest.java
@@ -35,13 +35,13 @@
 import org.apache.druid.query.QueryContexts;
 import org.apache.druid.query.QueryPlus;
 import org.apache.druid.query.QueryRunner;
-import org.apache.druid.query.QueryRunnerFactory;
 import org.apache.druid.query.QueryRunnerTestHelper;
 import org.apache.druid.query.Result;
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.segment.IncrementalIndexSegment;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.timeline.LogicalSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
 import org.junit.Assert;
@@ -119,10 +119,11 @@ public void testMaxIngestedEventTime() throws Exception
         .buildOnheap();
 
     final QueryRunner runner = QueryRunnerTestHelper.makeQueryRunner(
-        (QueryRunnerFactory) new DataSourceMetadataQueryRunnerFactory(
+        new DataSourceMetadataQueryRunnerFactory(
             new DataSourceQueryQueryToolChest(DefaultGenericQueryMetricsFactory.instance()),
             QueryRunnerTestHelper.NOOP_QUERYWATCHER
-        ), new IncrementalIndexSegment(rtIndex, "test"),
+        ),
+        new IncrementalIndexSegment(rtIndex, SegmentId.dummy("test")),
         null
     );
     DateTime timestamp = DateTimes.nowUtc();
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownInsufficientBufferTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownInsufficientBufferTest.java
index 99a8b646a661..7eb9b5057f8c 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownInsufficientBufferTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownInsufficientBufferTest.java
@@ -78,6 +78,7 @@
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -611,8 +612,8 @@ private List<QueryRunner<Row>> getRunner1()
     QueryableIndex index = groupByIndices.get(0);
     QueryRunner<Row> runner = makeQueryRunner(
         groupByFactory,
-        index.toString(),
-        new QueryableIndexSegment(index.toString(), index)
+        SegmentId.dummy(index.toString()),
+        new QueryableIndexSegment(index, SegmentId.dummy(index.toString()))
     );
     runners.add(groupByFactory.getToolchest().preMergeQueryDecoration(runner));
     return runners;
@@ -624,8 +625,8 @@ private List<QueryRunner<Row>> getRunner2()
     QueryableIndex index2 = groupByIndices.get(1);
     QueryRunner<Row> tooSmallRunner = makeQueryRunner(
         tooSmallGroupByFactory,
-        index2.toString(),
-        new QueryableIndexSegment(index2.toString(), index2)
+        SegmentId.dummy(index2.toString()),
+        new QueryableIndexSegment(index2, SegmentId.dummy(index2.toString()))
     );
     runners.add(tooSmallGroupByFactory.getToolchest().preMergeQueryDecoration(tooSmallRunner));
     return runners;
@@ -661,15 +662,12 @@ public ByteBuffer get()
 
   public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner(
       QueryRunnerFactory<T, QueryType> factory,
-      String segmentId,
+      SegmentId segmentId,
       Segment adapter
   )
   {
-    return new FinalizeResultsQueryRunner<T>(
-        new BySegmentQueryRunner<T>(
-            segmentId, adapter.getDataInterval().getStart(),
-            factory.createRunner(adapter)
-        ),
+    return new FinalizeResultsQueryRunner<>(
+        new BySegmentQueryRunner<>(segmentId, adapter.getDataInterval().getStart(), factory.createRunner(adapter)),
         (QueryToolChest<T, Query<T>>) factory.getToolchest()
     );
   }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownMultiNodeMergeTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownMultiNodeMergeTest.java
index 6b12b2d05415..0c196086d6e3 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownMultiNodeMergeTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownMultiNodeMergeTest.java
@@ -86,6 +86,7 @@
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTimeZone;
 import org.joda.time.Period;
 import org.junit.After;
@@ -712,8 +713,8 @@ private List<QueryRunner<Row>> getRunner1(int qIndexNumber)
     QueryableIndex index = groupByIndices.get(qIndexNumber);
     QueryRunner<Row> runner = makeQueryRunner(
         groupByFactory,
-        index.toString(),
-        new QueryableIndexSegment(index.toString(), index)
+        SegmentId.dummy(index.toString()),
+        new QueryableIndexSegment(index, SegmentId.dummy(index.toString()))
     );
     runners.add(groupByFactory.getToolchest().preMergeQueryDecoration(runner));
     return runners;
@@ -725,8 +726,8 @@ private List<QueryRunner<Row>> getRunner2(int qIndexNumber)
     QueryableIndex index2 = groupByIndices.get(qIndexNumber);
     QueryRunner<Row> tooSmallRunner = makeQueryRunner(
         groupByFactory2,
-        index2.toString(),
-        new QueryableIndexSegment(index2.toString(), index2)
+        SegmentId.dummy(index2.toString()),
+        new QueryableIndexSegment(index2, SegmentId.dummy(index2.toString()))
     );
     runners.add(groupByFactory2.getToolchest().preMergeQueryDecoration(tooSmallRunner));
     return runners;
@@ -762,13 +763,14 @@ public ByteBuffer get()
 
   public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner(
       QueryRunnerFactory<T, QueryType> factory,
-      String segmentId,
+      SegmentId segmentId,
       Segment adapter
   )
   {
     return new FinalizeResultsQueryRunner<T>(
         new BySegmentQueryRunner<T>(
-            segmentId, adapter.getDataInterval().getStart(),
+            segmentId,
+            adapter.getDataInterval().getStart(),
             factory.createRunner(adapter)
         ),
         (QueryToolChest<T, Query<T>>) factory.getToolchest()
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByMultiSegmentTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByMultiSegmentTest.java
index 708fb95aca8e..0e92f80c1f48 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByMultiSegmentTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByMultiSegmentTest.java
@@ -75,6 +75,7 @@
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -363,8 +364,8 @@ private List<QueryRunner<Row>> makeGroupByMultiRunners()
     for (QueryableIndex qindex : groupByIndices) {
       QueryRunner<Row> runner = makeQueryRunner(
           groupByFactory,
-          qindex.toString(),
-          new QueryableIndexSegment(qindex.toString(), qindex)
+          SegmentId.dummy(qindex.toString()),
+          new QueryableIndexSegment(qindex, SegmentId.dummy(qindex.toString()))
       );
       runners.add(groupByFactory.getToolchest().preMergeQueryDecoration(runner));
     }
@@ -401,7 +402,7 @@ public ByteBuffer get()
 
   public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner(
       QueryRunnerFactory<T, QueryType> factory,
-      String segmentId,
+      SegmentId segmentId,
       Segment adapter
   )
   {
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerFactoryTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerFactoryTest.java
index 6b1fa92a858d..0f7b86599357 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerFactoryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerFactoryTest.java
@@ -44,6 +44,7 @@
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.incremental.IncrementalIndex;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -170,6 +171,6 @@ private Segment createSegment() throws Exception
 
     closerRule.closeLater(incrementalIndex);
 
-    return new IncrementalIndexSegment(incrementalIndex, "test");
+    return new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("test"));
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
index ad73a2435b33..6bb8cc1d10bf 100644
--- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
@@ -34,6 +34,7 @@
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.column.ValueType;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -59,7 +60,7 @@ public void testIncrementalWorks()
   private void testIncrementalWorksHelper(EnumSet<SegmentMetadataQuery.AnalysisType> analyses)
   {
     final List<SegmentAnalysis> results = getSegmentAnalysises(
-        new IncrementalIndexSegment(TestIndex.getIncrementalTestIndex(), null),
+        new IncrementalIndexSegment(TestIndex.getIncrementalTestIndex(), SegmentId.dummy("ds")),
         analyses
     );
 
@@ -118,7 +119,7 @@ public void testMappedWorks()
   private void testMappedWorksHelper(EnumSet<SegmentMetadataQuery.AnalysisType> analyses)
   {
     final List<SegmentAnalysis> results = getSegmentAnalysises(
-        new QueryableIndexSegment("test_1", TestIndex.getMMappedTestIndex()),
+        new QueryableIndexSegment(TestIndex.getMMappedTestIndex(), SegmentId.dummy("test_1")),
         analyses
     );
 
diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java
index af912fdc71f2..97e6d808acef 100644
--- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java
@@ -54,6 +54,7 @@
 import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.timeline.LogicalSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 import org.junit.Assert;
 import org.junit.Test;
@@ -80,7 +81,7 @@ public class SegmentMetadataQueryTest
 
   @SuppressWarnings("unchecked")
   public static QueryRunner makeMMappedQueryRunner(
-      String segmentId,
+      SegmentId segmentId,
       boolean rollup,
       QueryRunnerFactory factory
   )
@@ -89,14 +90,14 @@ public static QueryRunner makeMMappedQueryRunner(
     return QueryRunnerTestHelper.makeQueryRunner(
         factory,
         segmentId,
-        new QueryableIndexSegment(segmentId, index),
+        new QueryableIndexSegment(index, segmentId),
         null
     );
   }
 
   @SuppressWarnings("unchecked")
   public static QueryRunner makeIncrementalIndexQueryRunner(
-      String segmentId,
+      SegmentId segmentId,
       boolean rollup,
       QueryRunnerFactory factory
   )
@@ -142,8 +143,8 @@ public SegmentMetadataQueryTest(
       boolean differentIds
   )
   {
-    final String id1 = differentIds ? "testSegment1" : "testSegment";
-    final String id2 = differentIds ? "testSegment2" : "testSegment";
+    final SegmentId id1 = SegmentId.dummy(differentIds ? "testSegment1" : "testSegment");
+    final SegmentId id2 = SegmentId.dummy(differentIds ? "testSegment2" : "testSegment");
     this.runner1 = mmap1
                    ? makeMMappedQueryRunner(id1, rollup1, FACTORY)
                    : makeIncrementalIndexQueryRunner(id1, rollup1, FACTORY);
@@ -169,7 +170,7 @@ public SegmentMetadataQueryTest(
                       .build();
 
     expectedSegmentAnalysis1 = new SegmentAnalysis(
-        id1,
+        id1.toString(),
         ImmutableList.of(Intervals.of("2011-01-12T00:00:00.000Z/2011-04-15T00:00:00.001Z")),
         ImmutableMap.of(
             "__time",
@@ -210,7 +211,7 @@ public SegmentMetadataQueryTest(
         null
     );
     expectedSegmentAnalysis2 = new SegmentAnalysis(
-        id2,
+        id2.toString(),
         ImmutableList.of(Intervals.of("2011-01-12T00:00:00.000Z/2011-04-15T00:00:00.001Z")),
         ImmutableMap.of(
             "__time",
diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java
index b15d1970ffd5..e8e60b99bc16 100644
--- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java
@@ -70,22 +70,18 @@ public static Iterable<Object[]> constructorFeeder()
         new Object[]{
             QueryRunnerTestHelper.makeUnionQueryRunner(
                 FACTORY,
-                new QueryableIndexSegment(
-                    QueryRunnerTestHelper.segmentId,
-                    TestIndex.getMMappedTestIndex()
-                ),
+                new QueryableIndexSegment(TestIndex.getMMappedTestIndex(), QueryRunnerTestHelper.segmentId),
                 null
-            ), true,
+            ),
+            true,
         },
         new Object[]{
             QueryRunnerTestHelper.makeUnionQueryRunner(
                 FACTORY,
-                new IncrementalIndexSegment(
-                    TestIndex.getIncrementalTestIndex(),
-                    QueryRunnerTestHelper.segmentId
-                ),
+                new IncrementalIndexSegment(TestIndex.getIncrementalTestIndex(), QueryRunnerTestHelper.segmentId),
                 null
-            ), false
+            ),
+            false
         }
     );
   }
@@ -95,7 +91,7 @@ public static Iterable<Object[]> constructorFeeder()
   public void testSegmentMetadataUnionQuery()
   {
     SegmentAnalysis expected = new SegmentAnalysis(
-        QueryRunnerTestHelper.segmentId,
+        QueryRunnerTestHelper.segmentId.toString(),
         Collections.singletonList(Intervals.of("2011-01-12T00:00:00.000Z/2011-04-15T00:00:00.001Z")),
         ImmutableMap.of(
             "placement",
diff --git a/processing/src/test/java/org/apache/druid/query/scan/MultiSegmentScanQueryTest.java b/processing/src/test/java/org/apache/druid/query/scan/MultiSegmentScanQueryTest.java
index 36cfe3e1e774..1349e1cf1419 100644
--- a/processing/src/test/java/org/apache/druid/query/scan/MultiSegmentScanQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/scan/MultiSegmentScanQueryTest.java
@@ -23,6 +23,8 @@
 import com.google.common.collect.Lists;
 import com.google.common.io.CharSource;
 import com.google.common.util.concurrent.MoreExecutors;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang.StringUtils;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.granularity.Granularities;
 import org.apache.druid.java.util.common.guava.MergeSequence;
@@ -40,10 +42,8 @@
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
-import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.NoneShardSpec;
-import org.apache.commons.io.IOUtils;
-import org.apache.commons.lang.StringUtils;
 import org.joda.time.Interval;
 import org.junit.AfterClass;
 import org.junit.Assert;
@@ -123,20 +123,14 @@ public static void setup() throws IOException
     segment1 = new IncrementalIndexSegment(index1, makeIdentifier(index1, "v1"));
   }
 
-  private static String makeIdentifier(IncrementalIndex index, String version)
+  private static SegmentId makeIdentifier(IncrementalIndex index, String version)
   {
     return makeIdentifier(index.getInterval(), version);
   }
 
-  private static String makeIdentifier(Interval interval, String version)
+  private static SegmentId makeIdentifier(Interval interval, String version)
   {
-    return DataSegment.makeDataSegmentIdentifier(
-        QueryRunnerTestHelper.dataSource,
-        interval.getStart(),
-        interval.getEnd(),
-        version,
-        NoneShardSpec.instance()
-    );
+    return SegmentId.of(QueryRunnerTestHelper.dataSource, interval, version, NoneShardSpec.instance());
   }
 
   private static IncrementalIndex newIndex(String minTimeStamp)
diff --git a/processing/src/test/java/org/apache/druid/query/scan/ScanQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/scan/ScanQueryRunnerTest.java
index 5fb8457780fd..226f2961c225 100644
--- a/processing/src/test/java/org/apache/druid/query/scan/ScanQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/scan/ScanQueryRunnerTest.java
@@ -647,13 +647,7 @@ private List<ScanResultValue> toExpected(
         end = group.size();
       }
       events.addAll(group.subList(offset, end));
-      expected.add(
-          new ScanResultValue(
-              QueryRunnerTestHelper.segmentId,
-              columns,
-              events
-          )
-      );
+      expected.add(new ScanResultValue(QueryRunnerTestHelper.segmentId.toString(), columns, events));
     }
     return expected;
   }
diff --git a/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerTest.java
index dfc2e8a8525d..cc1876a4c9d1 100644
--- a/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerTest.java
@@ -58,6 +58,7 @@
 import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -750,7 +751,9 @@ public void testSearchWithNullValueInDimension() throws Exception
         toolChest,
         QueryRunnerTestHelper.NOOP_QUERYWATCHER
     );
-    QueryRunner runner = factory.createRunner(new QueryableIndexSegment("asdf", TestIndex.persistRealtimeAndLoadMMapped(index)));
+    QueryRunner runner = factory.createRunner(
+        new QueryableIndexSegment(TestIndex.persistRealtimeAndLoadMMapped(index), SegmentId.dummy("asdf"))
+    );
     List<SearchHit> expectedHits = new ArrayList<>();
     expectedHits.add(new SearchHit("table", "table", 1));
     expectedHits.add(new SearchHit("table", NullHandling.defaultStringValue(), 1));
diff --git a/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerWithCaseTest.java b/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerWithCaseTest.java
index 007c15098769..cac1bcdc3d5f 100644
--- a/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerWithCaseTest.java
+++ b/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerWithCaseTest.java
@@ -35,6 +35,7 @@
 import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.incremental.IncrementalIndex;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -93,26 +94,26 @@ public static Iterable<Object[]> constructorFeeder()
       runners.addAll(Arrays.asList(
           makeQueryRunner(
               makeRunnerFactory(config),
-              "index1",
-              new IncrementalIndexSegment(index1, "index1"),
+              SegmentId.dummy("index1"),
+              new IncrementalIndexSegment(index1, SegmentId.dummy("index1")),
               "index1"
           ),
           makeQueryRunner(
               makeRunnerFactory(config),
-              "index2",
-              new IncrementalIndexSegment(index2, "index2"),
+              SegmentId.dummy("index2"),
+              new IncrementalIndexSegment(index2, SegmentId.dummy("index2")),
               "index2"
           ),
           makeQueryRunner(
               makeRunnerFactory(config),
-              "index3",
-              new QueryableIndexSegment("index3", index3),
+              SegmentId.dummy("index3"),
+              new QueryableIndexSegment(index3, SegmentId.dummy("index3")),
               "index3"
           ),
           makeQueryRunner(
               makeRunnerFactory(config),
-              "index4",
-              new QueryableIndexSegment("index4", index4),
+              SegmentId.dummy("index4"),
+              new QueryableIndexSegment(index4, SegmentId.dummy("index4")),
               "index4"
           )
       ));
diff --git a/processing/src/test/java/org/apache/druid/query/select/MultiSegmentSelectQueryTest.java b/processing/src/test/java/org/apache/druid/query/select/MultiSegmentSelectQueryTest.java
index 66722a0eb9d1..7080442f0b3c 100644
--- a/processing/src/test/java/org/apache/druid/query/select/MultiSegmentSelectQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/select/MultiSegmentSelectQueryTest.java
@@ -25,6 +25,8 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.io.CharSource;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang.StringUtils;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
@@ -45,13 +47,11 @@
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
-import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.apache.druid.timeline.partition.SingleElementPartitionChunk;
-import org.apache.commons.io.IOUtils;
-import org.apache.commons.lang.StringUtils;
 import org.joda.time.Interval;
 import org.junit.AfterClass;
 import org.junit.Assert;
@@ -148,33 +148,28 @@ public static void setup() throws IOException
     segment1 = new IncrementalIndexSegment(index1, makeIdentifier(index1, "v1"));
     segment_override = new IncrementalIndexSegment(index2, makeIdentifier(index2, "v2"));
 
-    VersionedIntervalTimeline<String, Segment> timeline = new VersionedIntervalTimeline(StringComparators.LEXICOGRAPHIC);
-    timeline.add(index0.getInterval(), "v1", new SingleElementPartitionChunk(segment0));
-    timeline.add(index1.getInterval(), "v1", new SingleElementPartitionChunk(segment1));
-    timeline.add(index2.getInterval(), "v2", new SingleElementPartitionChunk(segment_override));
+    VersionedIntervalTimeline<String, Segment> timeline =
+        new VersionedIntervalTimeline<>(StringComparators.LEXICOGRAPHIC);
+    timeline.add(index0.getInterval(), "v1", new SingleElementPartitionChunk<>(segment0));
+    timeline.add(index1.getInterval(), "v1", new SingleElementPartitionChunk<>(segment1));
+    timeline.add(index2.getInterval(), "v2", new SingleElementPartitionChunk<>(segment_override));
 
     segmentIdentifiers = Lists.newArrayList();
     for (TimelineObjectHolder<String, ?> holder : timeline.lookup(Intervals.of("2011-01-12/2011-01-14"))) {
-      segmentIdentifiers.add(makeIdentifier(holder.getInterval(), holder.getVersion()));
+      segmentIdentifiers.add(makeIdentifier(holder.getInterval(), holder.getVersion()).toString());
     }
 
     runner = QueryRunnerTestHelper.makeFilteringQueryRunner(timeline, factory);
   }
 
-  private static String makeIdentifier(IncrementalIndex index, String version)
+  private static SegmentId makeIdentifier(IncrementalIndex index, String version)
   {
     return makeIdentifier(index.getInterval(), version);
   }
 
-  private static String makeIdentifier(Interval interval, String version)
+  private static SegmentId makeIdentifier(Interval interval, String version)
   {
-    return DataSegment.makeDataSegmentIdentifier(
-        QueryRunnerTestHelper.dataSource,
-        interval.getStart(),
-        interval.getEnd(),
-        version,
-        NoneShardSpec.instance()
-    );
+    return SegmentId.of(QueryRunnerTestHelper.dataSource, interval, version, NoneShardSpec.instance());
   }
 
   private static IncrementalIndex newIndex(String minTimeStamp)
diff --git a/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
index 0574b656b660..09f01eea0052 100644
--- a/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
@@ -108,6 +108,8 @@ public class SelectQueryRunnerTest
       "2011-01-13T00:00:00.000Z\tupfront\tpremium\t1600\t16000.0\t160000\tpreferred\tp
preferred\t1564.617729\tvalue"
   };
 
+  private static final String segmentIdString = QueryRunnerTestHelper.segmentId.toString();
+
   public static final QuerySegmentSpec I_0112_0114 = new LegacySegmentSpec(Intervals.of("2011-01-12/2011-01-14"));
   public static final String[] V_0112_0114 = ObjectArrays.concat(V_0112, V_0113, String.class);
 
@@ -169,7 +171,7 @@ public void testFullOnSelect()
     HashMap<String, Object> context = new HashMap<String, Object>();
     Iterable<Result<SelectResultValue>> results = runner.run(QueryPlus.wrap(query), context).toList();
 
-    PagingOffset offset = query.getPagingOffset(QueryRunnerTestHelper.segmentId);
+    PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
         toFullEvents(V_0112_0114),
         Lists.newArrayList(
@@ -214,7 +216,7 @@ public void testSequentialPaging()
 
       SelectResultValue result = results.get(0).getValue();
       Map<String, Integer> pagingIdentifiers = result.getPagingIdentifiers();
-      Assert.assertEquals(offset, pagingIdentifiers.get(QueryRunnerTestHelper.segmentId).intValue());
+      Assert.assertEquals(offset, pagingIdentifiers.get(segmentIdString).intValue());
 
       Map<String, Integer> next = PagingSpec.next(pagingIdentifiers, descending);
       query = query.withPagingSpec(new PagingSpec(next, 3, false));
@@ -228,7 +230,7 @@ public void testSequentialPaging()
 
       SelectResultValue result = results.get(0).getValue();
       Map<String, Integer> pagingIdentifiers = result.getPagingIdentifiers();
-      Assert.assertEquals(offset, pagingIdentifiers.get(QueryRunnerTestHelper.segmentId).intValue());
+      Assert.assertEquals(offset, pagingIdentifiers.get(segmentIdString).intValue());
 
       // use identifier as-is but with fromNext=true
       query = query.withPagingSpec(new PagingSpec(pagingIdentifiers, 3, true));
@@ -270,14 +272,14 @@ public void testFullOnSelectWithDimensionSpec()
         new Result<SelectResultValue>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new SelectResultValue(
-                ImmutableMap.of(QueryRunnerTestHelper.segmentId, 2),
+                ImmutableMap.of(segmentIdString, 2),
                 Sets.newHashSet("mar", "qual", "place"),
                 Sets.newHashSet("index", "quality_uniques", "indexMin", "indexMaxPlusTen", "indexMinFloat",
                     "indexFloat", "indexMaxFloat"
                 ),
                 Arrays.asList(
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         0,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -288,7 +290,7 @@ public void testFullOnSelectWithDimensionSpec()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         1,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -299,7 +301,7 @@ public void testFullOnSelectWithDimensionSpec()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         2,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -318,14 +320,14 @@ public void testFullOnSelectWithDimensionSpec()
         new Result<SelectResultValue>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new SelectResultValue(
-                ImmutableMap.of(QueryRunnerTestHelper.segmentId, -3),
+                ImmutableMap.of(segmentIdString, -3),
                 Sets.newHashSet("mar", "qual", "place"),
                 Sets.newHashSet("index", "quality_uniques", "indexMin", "indexMaxPlusTen", "indexMinFloat",
                     "indexFloat", "indexMaxFloat"
                 ),
                 Arrays.asList(
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -1,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-04-15T00:00:00.000Z"))
@@ -336,7 +338,7 @@ public void testFullOnSelectWithDimensionSpec()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -2,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-04-15T00:00:00.000Z"))
@@ -347,7 +349,7 @@ public void testFullOnSelectWithDimensionSpec()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -3,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-04-15T00:00:00.000Z"))
@@ -377,7 +379,7 @@ public void testSelectWithDimsAndMets()
     HashMap<String, Object> context = new HashMap<String, Object>();
     Iterable<Result<SelectResultValue>> results = runner.run(QueryPlus.wrap(query), context).toList();
 
-    PagingOffset offset = query.getPagingOffset(QueryRunnerTestHelper.segmentId);
+    PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
         toEvents(
             new String[]{
@@ -413,7 +415,7 @@ public void testSelectPagination()
 
     Iterable<Result<SelectResultValue>> results = runner.run(QueryPlus.wrap(query), Maps.newHashMap()).toList();
 
-    PagingOffset offset = query.getPagingOffset(QueryRunnerTestHelper.segmentId);
+    PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
         toEvents(
             new String[]{
@@ -482,7 +484,7 @@ public void testFullOnSelectWithFilter()
           }
       );
 
-      PagingOffset offset = query.getPagingOffset(QueryRunnerTestHelper.segmentId);
+      PagingOffset offset = query.getPagingOffset(segmentIdString);
       List<Result<SelectResultValue>> expectedResults = toExpected(
           events,
           Collections.singletonList("quality"),
@@ -535,7 +537,7 @@ public void testFullOnSelectWithFilterOnVirtualColumn()
         }
     );
 
-    PagingOffset offset = query.getPagingOffset(QueryRunnerTestHelper.segmentId);
+    PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
         events,
         Collections.singletonList("quality"),
@@ -588,7 +590,7 @@ public void testSelectWithFilterLookupExtractionFn()
         }
     );
 
-    PagingOffset offset = query.getPagingOffset(QueryRunnerTestHelper.segmentId);
+    PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
         events,
         Collections.singletonList(QueryRunnerTestHelper.qualityDimension),
@@ -672,7 +674,7 @@ public void testFullSelectNoDimensionAndMetric()
         V_0112_0114
     );
 
-    PagingOffset offset = query.getPagingOffset(QueryRunnerTestHelper.segmentId);
+    PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
         events,
         Collections.singletonList("foo"),
@@ -704,12 +706,12 @@ public void testFullOnSelectWithLongAndFloat()
         new Result<SelectResultValue>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new SelectResultValue(
-                ImmutableMap.of(QueryRunnerTestHelper.segmentId, 2),
+                ImmutableMap.of(segmentIdString, 2),
                 Sets.newHashSet("null_column", "floatIndex", "longTime"),
                 Sets.newHashSet("__time", "index"),
                 Arrays.asList(
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         0,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -720,7 +722,7 @@ public void testFullOnSelectWithLongAndFloat()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         1,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -731,7 +733,7 @@ public void testFullOnSelectWithLongAndFloat()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         2,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -750,12 +752,12 @@ public void testFullOnSelectWithLongAndFloat()
         new Result<SelectResultValue>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new SelectResultValue(
-                ImmutableMap.of(QueryRunnerTestHelper.segmentId, -3),
+                ImmutableMap.of(segmentIdString, -3),
                 Sets.newHashSet("null_column", "floatIndex", "longTime"),
                 Sets.newHashSet("__time", "index"),
                 Arrays.asList(
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -1,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-13T00:00:00.000Z"))
@@ -766,7 +768,7 @@ public void testFullOnSelectWithLongAndFloat()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -2,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-13T00:00:00.000Z"))
@@ -777,7 +779,7 @@ public void testFullOnSelectWithLongAndFloat()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -3,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-13T00:00:00.000Z"))
@@ -819,12 +821,12 @@ public void testFullOnSelectWithLongAndFloatWithExFn()
         new Result<SelectResultValue>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new SelectResultValue(
-                ImmutableMap.of(QueryRunnerTestHelper.segmentId, 2),
+                ImmutableMap.of(segmentIdString, 2),
                 Sets.newHashSet("null_column", "floatIndex", "longTime"),
                 Sets.newHashSet("__time", "index"),
                 Arrays.asList(
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         0,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -835,7 +837,7 @@ public void testFullOnSelectWithLongAndFloatWithExFn()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         1,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -846,7 +848,7 @@ public void testFullOnSelectWithLongAndFloatWithExFn()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         2,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -865,12 +867,12 @@ public void testFullOnSelectWithLongAndFloatWithExFn()
         new Result<SelectResultValue>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new SelectResultValue(
-                ImmutableMap.of(QueryRunnerTestHelper.segmentId, -3),
+                ImmutableMap.of(segmentIdString, -3),
                 Sets.newHashSet("null_column", "floatIndex", "longTime"),
                 Sets.newHashSet("__time", "index"),
                 Arrays.asList(
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -1,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-13T00:00:00.000Z"))
@@ -881,7 +883,7 @@ public void testFullOnSelectWithLongAndFloatWithExFn()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -2,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-13T00:00:00.000Z"))
@@ -892,7 +894,7 @@ public void testFullOnSelectWithLongAndFloatWithExFn()
                             .build()
                     ),
                     new EventHolder(
-                        QueryRunnerTestHelper.segmentId,
+                        segmentIdString,
                         -3,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-13T00:00:00.000Z"))
@@ -912,10 +914,7 @@ public void testFullOnSelectWithLongAndFloatWithExFn()
 
   private Map<String, Integer> toPagingIdentifier(int startDelta, boolean descending)
   {
-    return ImmutableMap.of(
-        QueryRunnerTestHelper.segmentId,
-        PagingOffset.toOffset(startDelta, descending)
-    );
+    return ImmutableMap.of(segmentIdString, PagingOffset.toOffset(startDelta, descending));
   }
 
   private List<List<Map<String, Object>>> toFullEvents(final String[]... valueSet)
@@ -993,12 +992,12 @@ private List<Result<SelectResultValue>> toExpected(
         int start = group.size() + offset;
         int end = Math.max(-1, start - threshold);
         for (int i = start; i > end; i--) {
-          holders.add(new EventHolder(QueryRunnerTestHelper.segmentId, newOffset--, group.get(i)));
+          holders.add(new EventHolder(segmentIdString, newOffset--, group.get(i)));
         }
       } else {
         int end = Math.min(group.size(), offset + threshold);
         for (int i = offset; i < end; i++) {
-          holders.add(new EventHolder(QueryRunnerTestHelper.segmentId, newOffset++, group.get(i)));
+          holders.add(new EventHolder(segmentIdString, newOffset++, group.get(i)));
         }
       }
       int lastOffset = holders.isEmpty() ? offset : holders.get(holders.size() - 1).getOffset();
@@ -1006,7 +1005,7 @@ private List<Result<SelectResultValue>> toExpected(
           new Result(
               new DateTime(group.get(0).get(EventHolder.timestampKey), ISOChronology.getInstanceUTC()),
               new SelectResultValue(
-                  ImmutableMap.of(QueryRunnerTestHelper.segmentId, lastOffset),
+                  ImmutableMap.of(segmentIdString, lastOffset),
                   Sets.newHashSet(dimensions),
                   Sets.newHashSet(metrics),
                   holders)
diff --git a/processing/src/test/java/org/apache/druid/query/timeboundary/TimeBoundaryQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/timeboundary/TimeBoundaryQueryRunnerTest.java
index 16d30acf5134..e64a89609b90 100644
--- a/processing/src/test/java/org/apache/druid/query/timeboundary/TimeBoundaryQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/timeboundary/TimeBoundaryQueryRunnerTest.java
@@ -23,6 +23,7 @@
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.io.CharSource;
+import org.apache.commons.lang.StringUtils;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.granularity.Granularities;
@@ -39,12 +40,11 @@
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
-import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.apache.druid.timeline.partition.SingleElementPartitionChunk;
-import org.apache.commons.lang.StringUtils;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
 import org.junit.Assert;
@@ -126,20 +126,14 @@ private static IncrementalIndex newIndex(String minTimeStamp, int maxRowCount)
         .buildOnheap();
   }
 
-  private static String makeIdentifier(IncrementalIndex index, String version)
+  private static SegmentId makeIdentifier(IncrementalIndex index, String version)
   {
     return makeIdentifier(index.getInterval(), version);
   }
 
-  private static String makeIdentifier(Interval interval, String version)
+  private static SegmentId makeIdentifier(Interval interval, String version)
   {
-    return DataSegment.makeDataSegmentIdentifier(
-        QueryRunnerTestHelper.dataSource,
-        interval.getStart(),
-        interval.getEnd(),
-        version,
-        new NoneShardSpec()
-    );
+    return SegmentId.of(QueryRunnerTestHelper.dataSource, interval, version, NoneShardSpec.instance());
   }
 
   private QueryRunner getCustomRunner() throws IOException
@@ -153,13 +147,14 @@ private QueryRunner getCustomRunner() throws IOException
     segment0 = new IncrementalIndexSegment(index0, makeIdentifier(index0, "v1"));
     segment1 = new IncrementalIndexSegment(index1, makeIdentifier(index1, "v1"));
 
-    VersionedIntervalTimeline<String, Segment> timeline = new VersionedIntervalTimeline(StringComparators.LEXICOGRAPHIC);
-    timeline.add(index0.getInterval(), "v1", new SingleElementPartitionChunk(segment0));
-    timeline.add(index1.getInterval(), "v1", new SingleElementPartitionChunk(segment1));
+    VersionedIntervalTimeline<String, Segment> timeline =
+        new VersionedIntervalTimeline<>(StringComparators.LEXICOGRAPHIC);
+    timeline.add(index0.getInterval(), "v1", new SingleElementPartitionChunk<>(segment0));
+    timeline.add(index1.getInterval(), "v1", new SingleElementPartitionChunk<>(segment1));
 
     segmentIdentifiers = Lists.newArrayList();
     for (TimelineObjectHolder<String, ?> holder : timeline.lookup(Intervals.of("2011-01-12/2011-01-17"))) {
-      segmentIdentifiers.add(makeIdentifier(holder.getInterval(), holder.getVersion()));
+      segmentIdentifiers.add(makeIdentifier(holder.getInterval(), holder.getVersion()).toString());
     }
 
     return QueryRunnerTestHelper.makeFilteringQueryRunner(timeline, factory);
diff --git a/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerBonusTest.java b/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerBonusTest.java
index 81e01b1581fa..824552203d9f 100644
--- a/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerBonusTest.java
+++ b/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerBonusTest.java
@@ -38,6 +38,7 @@
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -111,15 +112,14 @@ public void testOneRowAtATime() throws Exception
   private List<Result<TimeseriesResultValue>> runTimeseriesCount(IncrementalIndex index)
   {
     final QueryRunnerFactory factory = new TimeseriesQueryRunnerFactory(
-        new TimeseriesQueryQueryToolChest(
-            QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator()),
+        new TimeseriesQueryQueryToolChest(QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator()),
         new TimeseriesQueryEngine(),
         QueryRunnerTestHelper.NOOP_QUERYWATCHER
     );
 
     final QueryRunner<Result<TimeseriesResultValue>> runner = makeQueryRunner(
         factory,
-        new IncrementalIndexSegment(index, null)
+        new IncrementalIndexSegment(index, SegmentId.dummy("ds"))
     );
 
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
@@ -133,14 +133,8 @@ private List<Result<TimeseriesResultValue>> runTimeseriesCount(IncrementalIndex
     return runner.run(QueryPlus.wrap(query), context).toList();
   }
 
-  private static <T> QueryRunner<T> makeQueryRunner(
-      QueryRunnerFactory<T, Query<T>> factory,
-      Segment adapter
-  )
+  private static <T> QueryRunner<T> makeQueryRunner(QueryRunnerFactory<T, Query<T>> factory, Segment adapter)
   {
-    return new FinalizeResultsQueryRunner<T>(
-        factory.createRunner(adapter),
-        factory.getToolchest()
-    );
+    return new FinalizeResultsQueryRunner<>(factory.createRunner(adapter), factory.getToolchest());
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryQueryToolChestTest.java b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryQueryToolChestTest.java
index b8207b9381a1..3463ba8d356c 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryQueryToolChestTest.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryQueryToolChestTest.java
@@ -47,6 +47,7 @@
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.segment.VirtualColumns;
 import org.apache.druid.segment.column.ValueType;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -59,7 +60,7 @@
 public class TopNQueryQueryToolChestTest
 {
 
-  private static final String segmentId = "testSegment";
+  private static final SegmentId segmentId = SegmentId.dummy("testSegment");
 
   @Test
   public void testCacheStrategy() throws Exception
diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java
index 5bf9f8eb3304..c35abc8756d0 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java
@@ -35,6 +35,7 @@
 import org.apache.druid.segment.IncrementalIndexSegment;
 import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.TestIndex;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.BeforeClass;
 import org.junit.Ignore;
 import org.junit.Test;
@@ -56,7 +57,7 @@ public enum TestCases
   }
 
   private static final String marketDimension = "market";
-  private static final String segmentId = "testSegment";
+  private static final SegmentId segmentId = SegmentId.dummy("testSegment");
 
   private static final HashMap<String, Object> context = new HashMap<String, Object>();
 
@@ -114,7 +115,7 @@ public ByteBuffer get()
         TestCases.mMappedTestIndex,
         QueryRunnerTestHelper.makeQueryRunner(
             factory,
-            new QueryableIndexSegment(segmentId, TestIndex.getMMappedTestIndex()),
+            new QueryableIndexSegment(TestIndex.getMMappedTestIndex(), segmentId),
             null
         )
     );
@@ -122,7 +123,7 @@ public ByteBuffer get()
         TestCases.mergedRealtimeIndex,
         QueryRunnerTestHelper.makeQueryRunner(
             factory,
-            new QueryableIndexSegment(segmentId, TestIndex.mergedRealtimeIndex()),
+            new QueryableIndexSegment(TestIndex.mergedRealtimeIndex(), segmentId),
             null
         )
     );
diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerTest.java
index d805065b1a76..27427e7f5530 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerTest.java
@@ -3766,17 +3766,12 @@ public void testTopNBySegmentResults()
     );
 
     @SuppressWarnings("unused") // TODO: fix this test
-    List<Result<BySegmentResultValueClass>> expectedResults = Collections.singletonList(
-        new Result<BySegmentResultValueClass>(
+    List<Result<BySegmentResultValueClass<Result<TopNResultValue>>>> expectedResults = Collections.singletonList(
+        new Result<>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
-            new BySegmentResultValueClass(
-                Collections.singletonList(
-                    new Result<TopNResultValue>(
-                        DateTimes.of("2011-01-12T00:00:00.000Z"),
-                        topNResult
-                    )
-                ),
-                QueryRunnerTestHelper.segmentId,
+            new BySegmentResultValueClass<>(
+                Collections.singletonList(new Result<>(DateTimes.of("2011-01-12T00:00:00.000Z"), topNResult)),
+                QueryRunnerTestHelper.segmentId.toString(),
                 Intervals.of("1970-01-01T00:00:00.000Z/2020-01-01T00:00:00.000Z")
             )
         )
diff --git a/processing/src/test/java/org/apache/druid/segment/AppendTest.java b/processing/src/test/java/org/apache/druid/segment/AppendTest.java
index 6b52e122b35c..7358f8bb09f7 100644
--- a/processing/src/test/java/org/apache/druid/segment/AppendTest.java
+++ b/processing/src/test/java/org/apache/druid/segment/AppendTest.java
@@ -130,22 +130,19 @@ public void setUp()
             Intervals.of("2011-01-14T22:00:00.000Z/2011-01-16T00:00:00.000Z")
         )
     );
-    segment = new QueryableIndexSegment(null, appendedIndex);
+    segment = new QueryableIndexSegment(appendedIndex, null);
 
     // (3, 4) cover overlapping segments of the form
     // |------------|
     //     |-----|
     QueryableIndex append2 = schemalessIndexTest.getAppendedIncrementalIndex(
-        Arrays.asList(
-            new Pair<String, AggregatorFactory[]>("append.json.3", METRIC_AGGS_NO_UNIQ),
-            new Pair<String, AggregatorFactory[]>("append.json.4", METRIC_AGGS)
-        ),
+        Arrays.asList(new Pair<>("append.json.3", METRIC_AGGS_NO_UNIQ), new Pair<>("append.json.4", METRIC_AGGS)),
         Arrays.asList(
             Intervals.of("2011-01-12T00:00:00.000Z/2011-01-16T00:00:00.000Z"),
             Intervals.of("2011-01-13T00:00:00.000Z/2011-01-14T00:00:00.000Z")
         )
     );
-    segment2 = new QueryableIndexSegment(null, append2);
+    segment2 = new QueryableIndexSegment(append2, null);
 
     // (5, 6, 7) test gaps that can be created in data because of rows being discounted
     // |-------------|
@@ -153,9 +150,9 @@ public void setUp()
     //          |---|
     QueryableIndex append3 = schemalessIndexTest.getAppendedIncrementalIndex(
         Arrays.asList(
-            new Pair<String, AggregatorFactory[]>("append.json.5", METRIC_AGGS),
-            new Pair<String, AggregatorFactory[]>("append.json.6", METRIC_AGGS),
-            new Pair<String, AggregatorFactory[]>("append.json.7", METRIC_AGGS)
+            new Pair<>("append.json.5", METRIC_AGGS),
+            new Pair<>("append.json.6", METRIC_AGGS),
+            new Pair<>("append.json.7", METRIC_AGGS)
         ),
         Arrays.asList(
             Intervals.of("2011-01-12T00:00:00.000Z/2011-01-22T00:00:00.000Z"),
@@ -163,14 +160,14 @@ public void setUp()
             Intervals.of("2011-01-18T00:00:00.000Z/2011-01-21T00:00:00.000Z")
         )
     );
-    segment3 = new QueryableIndexSegment(null, append3);
+    segment3 = new QueryableIndexSegment(append3, null);
   }
 
   @Test
   public void testTimeBoundary()
   {
     List<Result<TimeBoundaryResultValue>> expectedResults = Collections.singletonList(
-        new Result<TimeBoundaryResultValue>(
+        new Result<>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new TimeBoundaryResultValue(
                 ImmutableMap.of(
diff --git a/processing/src/test/java/org/apache/druid/segment/IndexMergerV9WithSpatialIndexTest.java b/processing/src/test/java/org/apache/druid/segment/IndexMergerV9WithSpatialIndexTest.java
index bd5d144735ec..f69d59d8a230 100644
--- a/processing/src/test/java/org/apache/druid/segment/IndexMergerV9WithSpatialIndexTest.java
+++ b/processing/src/test/java/org/apache/druid/segment/IndexMergerV9WithSpatialIndexTest.java
@@ -23,6 +23,7 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+import org.apache.commons.io.FileUtils;
 import org.apache.druid.collections.spatial.search.RadiusBound;
 import org.apache.druid.collections.spatial.search.RectangularBound;
 import org.apache.druid.data.input.MapBasedInputRow;
@@ -31,7 +32,6 @@
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.granularity.Granularities;
-import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
 import org.apache.druid.query.Druids;
 import org.apache.druid.query.FinalizeResultsQueryRunner;
 import org.apache.druid.query.QueryPlus;
@@ -49,7 +49,7 @@
 import org.apache.druid.query.timeseries.TimeseriesResultValue;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
-import org.apache.commons.io.FileUtils;
+import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
 import org.joda.time.Interval;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -94,8 +94,8 @@ public static Collection<?> constructorFeeder() throws IOException
       final QueryableIndex mMappedTestIndex = makeQueryableIndex(indexSpec, indexMergerV9, indexIO);
       final QueryableIndex mergedRealtimeIndex = makeMergedQueryableIndex(indexSpec, indexMergerV9, indexIO);
       argumentArrays.add(new Object[] {new IncrementalIndexSegment(rtIndex, null)});
-      argumentArrays.add(new Object[] {new QueryableIndexSegment(null, mMappedTestIndex)});
-      argumentArrays.add(new Object[] {new QueryableIndexSegment(null, mergedRealtimeIndex)});
+      argumentArrays.add(new Object[] {new QueryableIndexSegment(mMappedTestIndex, null)});
+      argumentArrays.add(new Object[] {new QueryableIndexSegment(mergedRealtimeIndex, null)});
     }
     return argumentArrays;
   }
diff --git a/processing/src/test/java/org/apache/druid/segment/ReferenceCountingSegmentTest.java b/processing/src/test/java/org/apache/druid/segment/ReferenceCountingSegmentTest.java
index dcd3de43c490..62c37846175c 100644
--- a/processing/src/test/java/org/apache/druid/segment/ReferenceCountingSegmentTest.java
+++ b/processing/src/test/java/org/apache/druid/segment/ReferenceCountingSegmentTest.java
@@ -21,6 +21,7 @@
 
 import com.google.common.base.Throwables;
 import org.apache.druid.java.util.common.DateTimes;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Days;
 import org.joda.time.Interval;
 import org.junit.Assert;
@@ -45,9 +46,9 @@ public void setUp()
         new AbstractSegment()
         {
           @Override
-          public String getIdentifier()
+          public SegmentId getId()
           {
-            return "test_segment";
+            return SegmentId.dummy("test_segment");
           }
 
           @Override
diff --git a/processing/src/test/java/org/apache/druid/segment/SchemalessTestFullTest.java b/processing/src/test/java/org/apache/druid/segment/SchemalessTestFullTest.java
index 1f9ad939ea05..a48dba24887a 100644
--- a/processing/src/test/java/org/apache/druid/segment/SchemalessTestFullTest.java
+++ b/processing/src/test/java/org/apache/druid/segment/SchemalessTestFullTest.java
@@ -945,9 +945,7 @@ public void testEmptySchemas()
     );
 
     runTests(
-        new QueryableIndexSegment(
-            null, schemalessIndexTest.getMergedIncrementalIndex(0, 0)
-        ),
+        new QueryableIndexSegment(schemalessIndexTest.getMergedIncrementalIndex(0, 0), null),
         expectedTimeseriesResults,
         expectedFilteredTimeSeriesResults,
         expectedTopNResults,
@@ -1030,9 +1028,7 @@ public void testExactSameSchemas()
     );
 
     runTests(
-        new QueryableIndexSegment(
-            null, schemalessIndexTest.getMergedIncrementalIndex(1, 1)
-        ),
+        new QueryableIndexSegment(schemalessIndexTest.getMergedIncrementalIndex(1, 1), null),
         expectedTimeseriesResults,
         expectedFilteredTimeSeriesResults,
         expectedTopNResults,
@@ -1162,7 +1158,7 @@ public void testMultiDimensionalValues()
     );
 
     runTests(
-        new QueryableIndexSegment(null, schemalessIndexTest.getMergedIncrementalIndex(new int[]{6, 7, 8})),
+        new QueryableIndexSegment(schemalessIndexTest.getMergedIncrementalIndex(new int[]{6, 7, 8}), null),
         expectedTimeseriesResults,
         expectedFilteredTimeSeriesResults,
         expectedTopNResults,
@@ -1353,7 +1349,7 @@ public void testDifferentMetrics()
     );
 
     runTests(
-        new QueryableIndexSegment(null, schemalessIndexTest.getMergedIncrementalIndexDiffMetrics()),
+        new QueryableIndexSegment(schemalessIndexTest.getMergedIncrementalIndexDiffMetrics(), null),
         expectedTimeseriesResults,
         expectedFilteredTimeSeriesResults,
         expectedTopNResults,
@@ -1402,7 +1398,7 @@ private void testAll(
   {
     for (Pair<QueryableIndex, String> entry : getIndexes(index1, index2)) {
       runTests(
-          new QueryableIndexSegment(null, entry.lhs),
+          new QueryableIndexSegment(entry.lhs, null),
           expectedTimeseriesResults,
           expectedFilteredTimeseriesResults,
           expectedTopNResults,
diff --git a/processing/src/test/java/org/apache/druid/segment/SchemalessTestSimpleTest.java b/processing/src/test/java/org/apache/druid/segment/SchemalessTestSimpleTest.java
index b16157e369ae..9895c6407bbf 100644
--- a/processing/src/test/java/org/apache/druid/segment/SchemalessTestSimpleTest.java
+++ b/processing/src/test/java/org/apache/druid/segment/SchemalessTestSimpleTest.java
@@ -84,8 +84,8 @@ public static Collection<?> constructorFeeder()
       final QueryableIndex persistedIncrementalIndex = TestIndex.persistRealtimeAndLoadMMapped(incrementalIndex);
       final QueryableIndex mergedIncrementalIndex = schemalessIndexTest.getMergedIncrementalIndex();
       argumentArrays.add(new Object[] {new IncrementalIndexSegment(incrementalIndex, null), false});
-      argumentArrays.add(new Object[] {new QueryableIndexSegment(null, persistedIncrementalIndex), false});
-      argumentArrays.add(new Object[] {new QueryableIndexSegment(null, mergedIncrementalIndex), true});
+      argumentArrays.add(new Object[] {new QueryableIndexSegment(persistedIncrementalIndex, null), false});
+      argumentArrays.add(new Object[] {new QueryableIndexSegment(mergedIncrementalIndex, null), true});
     }
     return argumentArrays;
   }
diff --git a/processing/src/test/java/org/apache/druid/segment/filter/SpatialFilterBonusTest.java b/processing/src/test/java/org/apache/druid/segment/filter/SpatialFilterBonusTest.java
index 88840a4494b7..6abecf84f137 100644
--- a/processing/src/test/java/org/apache/druid/segment/filter/SpatialFilterBonusTest.java
+++ b/processing/src/test/java/org/apache/druid/segment/filter/SpatialFilterBonusTest.java
@@ -108,8 +108,8 @@ public static Collection<?> constructorFeeder() throws IOException
       final QueryableIndex mMappedTestIndex = makeQueryableIndex(indexSpec, indexMerger, indexIO);
       final QueryableIndex mergedRealtimeIndex = makeMergedQueryableIndex(indexSpec, indexMerger, indexIO);
       argumentArrays.add(new Object[] {new IncrementalIndexSegment(rtIndex, null)});
-      argumentArrays.add(new Object[] {new QueryableIndexSegment(null, mMappedTestIndex)});
-      argumentArrays.add(new Object[] {new QueryableIndexSegment(null, mergedRealtimeIndex)});
+      argumentArrays.add(new Object[] {new QueryableIndexSegment(mMappedTestIndex, null)});
+      argumentArrays.add(new Object[] {new QueryableIndexSegment(mergedRealtimeIndex, null)});
     }
     return argumentArrays;
   }
diff --git a/processing/src/test/java/org/apache/druid/segment/filter/SpatialFilterTest.java b/processing/src/test/java/org/apache/druid/segment/filter/SpatialFilterTest.java
index 14bbe8974cba..cc0b76d1d217 100644
--- a/processing/src/test/java/org/apache/druid/segment/filter/SpatialFilterTest.java
+++ b/processing/src/test/java/org/apache/druid/segment/filter/SpatialFilterTest.java
@@ -102,10 +102,10 @@ public static Collection<?> constructorFeeder() throws IOException
                 new IncrementalIndexSegment(rtIndex, null)
             },
             {
-                new QueryableIndexSegment(null, mMappedTestIndex)
+                new QueryableIndexSegment(mMappedTestIndex, null)
             },
             {
-                new QueryableIndexSegment(null, mergedRealtimeIndex)
+                new QueryableIndexSegment(mergedRealtimeIndex, null)
             }
         }
     );
diff --git a/server/src/main/java/org/apache/druid/client/AbstractCuratorServerInventoryView.java b/server/src/main/java/org/apache/druid/client/AbstractCuratorServerInventoryView.java
index dfb1ac3876cc..393513f4de34 100644
--- a/server/src/main/java/org/apache/druid/client/AbstractCuratorServerInventoryView.java
+++ b/server/src/main/java/org/apache/druid/client/AbstractCuratorServerInventoryView.java
@@ -33,6 +33,7 @@
 import org.apache.druid.java.util.emitter.EmittingLogger;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.curator.framework.CuratorFramework;
+import org.apache.druid.timeline.SegmentId;
 
 import java.io.IOException;
 import java.util.Collection;
@@ -138,9 +139,7 @@ public DruidServer addInventory(
           }
 
           @Override
-          public DruidServer updateInventory(
-              DruidServer container, String inventoryKey, InventoryType inventory
-          )
+          public DruidServer updateInventory(DruidServer container, String inventoryKey, InventoryType inventory)
           {
             return updateInnerInventory(container, inventoryKey, inventory);
           }
@@ -248,17 +247,14 @@ private void runServerRemovedCallbacks(final DruidServer server)
     }
   }
 
-  protected void addSingleInventory(
-      final DruidServer container,
-      final DataSegment inventory
-  )
+  protected void addSingleInventory(final DruidServer container, final DataSegment inventory)
   {
-    log.debug("Server[%s] added segment[%s]", container.getName(), inventory.getIdentifier());
+    log.debug("Server[%s] added segment[%s]", container.getName(), inventory.getId());
 
-    if (container.getSegment(inventory.getIdentifier()) != null) {
+    if (container.getSegment(inventory.getId()) != null) {
       log.warn(
           "Not adding or running callbacks for existing segment[%s] on server[%s]",
-          inventory.getIdentifier(),
+          inventory.getId(),
           container.getName()
       );
 
@@ -272,34 +268,52 @@ protected void addSingleInventory(
     );
   }
 
-  protected void removeSingleInventory(final DruidServer container, String inventoryKey)
+  void removeSingleInventory(DruidServer container, SegmentId segmentId)
   {
-    log.debug("Server[%s] removed segment[%s]", container.getName(), inventoryKey);
-    final DataSegment segment = container.getSegment(inventoryKey);
-
-    if (segment == null) {
+    log.debug("Server[%s] removed segment[%s]", container.getName(), segmentId);
+    if (!doRemoveSingleInventory(container, segmentId)) {
       log.warn(
           "Not running cleanup or callbacks for non-existing segment[%s] on server[%s]",
-          inventoryKey,
+          segmentId,
           container.getName()
       );
-
-      return;
     }
+  }
 
-    container.removeDataSegment(inventoryKey);
-
-    runSegmentCallbacks(
-        input -> input.segmentRemoved(container.getMetadata(), segment)
+  void removeSingleInventory(final DruidServer container, String segmentId)
+  {
+    log.debug("Server[%s] removed segment[%s]", container.getName(), segmentId);
+    for (SegmentId possibleSegmentId : SegmentId.iterateAllPossibleParsings(segmentId)) {
+      if (doRemoveSingleInventory(container, possibleSegmentId)) {
+        return;
+      }
+    }
+    log.warn(
+        "Not running cleanup or callbacks for non-existing segment[%s] on server[%s]",
+        segmentId,
+        container.getName()
     );
   }
 
+  private boolean doRemoveSingleInventory(DruidServer container, SegmentId segmentId)
+  {
+    DataSegment segment = container.removeDataSegment(segmentId);
+    if (segment != null) {
+      runSegmentCallbacks(
+          input -> input.segmentRemoved(container.getMetadata(), segment)
+      );
+      return true;
+    } else {
+      return false;
+    }
+  }
+
   @Override
   public boolean isSegmentLoadedByServer(String serverKey, DataSegment segment)
   {
     try {
       DruidServer server = getInventoryValue(serverKey);
-      return server != null && server.getSegment(segment.getIdentifier()) != null;
+      return server != null && server.getSegment(segment.getId()) != null;
     }
     catch (Exception ex) {
       throw Throwables.propagate(ex);
@@ -318,10 +332,7 @@ protected abstract DruidServer updateInnerInventory(
       InventoryType inventory
   );
 
-  protected abstract DruidServer removeInnerInventory(
-      DruidServer container,
-      String inventoryKey
-  );
+  protected abstract DruidServer removeInnerInventory(DruidServer container, String inventoryKey);
 
   protected abstract void segmentCallbackRemoved(SegmentCallback callback);
 }
diff --git a/server/src/main/java/org/apache/druid/client/BatchServerInventoryView.java b/server/src/main/java/org/apache/druid/client/BatchServerInventoryView.java
index 8160ff7d8512..ce6bafcc7315 100644
--- a/server/src/main/java/org/apache/druid/client/BatchServerInventoryView.java
+++ b/server/src/main/java/org/apache/druid/client/BatchServerInventoryView.java
@@ -147,7 +147,7 @@ protected DruidServer updateInnerInventory(
       addSingleInventory(container, segment);
     }
     for (DataSegment segment : Sets.difference(existing, filteredInventory)) {
-      removeSingleInventory(container, segment.getIdentifier());
+      removeSingleInventory(container, segment.getId());
     }
     zNodes.put(inventoryKey, filteredInventory);
 
@@ -166,7 +166,7 @@ protected DruidServer removeInnerInventory(final DruidServer container, String i
     }
 
     for (DataSegment segment : segments) {
-      removeSingleInventory(container, segment.getIdentifier());
+      removeSingleInventory(container, segment.getId());
     }
     return container;
   }
diff --git a/server/src/main/java/org/apache/druid/client/BrokerServerView.java b/server/src/main/java/org/apache/druid/client/BrokerServerView.java
index cbfd7171fbd5..8a234a59c51a 100644
--- a/server/src/main/java/org/apache/druid/client/BrokerServerView.java
+++ b/server/src/main/java/org/apache/druid/client/BrokerServerView.java
@@ -41,6 +41,7 @@
 import org.apache.druid.query.QueryWatcher;
 import org.apache.druid.server.coordination.DruidServerMetadata;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.PartitionChunk;
 
@@ -61,7 +62,7 @@ public class BrokerServerView implements TimelineServerView
   private final Object lock = new Object();
 
   private final ConcurrentMap<String, QueryableDruidServer> clients;
-  private final Map<String, ServerSelector> selectors;
+  private final Map<SegmentId, ServerSelector> selectors;
   private final Map<String, VersionedIntervalTimeline<String, ServerSelector>> timelines;
   private final ConcurrentMap<TimelineCallback, Executor> timelineCallbacks = new ConcurrentHashMap<>();
 
@@ -186,7 +187,7 @@ private DirectDruidClient makeDirectClient(DruidServer server)
 
   private QueryableDruidServer removeServer(DruidServer server)
   {
-    for (DataSegment segment : server.getSegments().values()) {
+    for (DataSegment segment : server.getSegments()) {
       serverRemovedSegment(server.getMetadata(), segment);
     }
     return clients.remove(server.getName());
@@ -194,9 +195,7 @@ private QueryableDruidServer removeServer(DruidServer server)
 
   private void serverAddedSegment(final DruidServerMetadata server, final DataSegment segment)
   {
-
-
-    String segmentId = segment.getIdentifier();
+    SegmentId segmentId = segment.getId();
     synchronized (lock) {
       log.debug("Adding segment[%s] for server[%s]", segment, server);
 
@@ -225,8 +224,7 @@ private void serverAddedSegment(final DruidServerMetadata server, final DataSegm
 
   private void serverRemovedSegment(DruidServerMetadata server, DataSegment segment)
   {
-
-    String segmentId = segment.getIdentifier();
+    SegmentId segmentId = segment.getId();
     final ServerSelector selector;
 
     synchronized (lock) {
diff --git a/server/src/main/java/org/apache/druid/client/CacheUtil.java b/server/src/main/java/org/apache/druid/client/CacheUtil.java
index 027db74b2f1f..a563fd80b95a 100644
--- a/server/src/main/java/org/apache/druid/client/CacheUtil.java
+++ b/server/src/main/java/org/apache/druid/client/CacheUtil.java
@@ -33,7 +33,7 @@
 public class CacheUtil
 {
   public static Cache.NamedKey computeSegmentCacheKey(
-      String segmentIdentifier,
+      String segmentId,
       SegmentDescriptor descriptor,
       byte[] queryCacheKey
   )
@@ -42,7 +42,7 @@ public static Cache.NamedKey computeSegmentCacheKey(
     final byte[] versionBytes = StringUtils.toUtf8(descriptor.getVersion());
 
     return new Cache.NamedKey(
-        segmentIdentifier, ByteBuffer
+        segmentId, ByteBuffer
         .allocate(16 + versionBytes.length + 4 + queryCacheKey.length)
         .putLong(segmentQueryInterval.getStartMillis())
         .putLong(segmentQueryInterval.getEndMillis())
diff --git a/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java b/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
index 99df5f0a06f9..77c1cddc1850 100644
--- a/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
+++ b/server/src/main/java/org/apache/druid/client/CachingClusteredClient.java
@@ -68,6 +68,7 @@
 import org.apache.druid.server.QueryResource;
 import org.apache.druid.server.coordination.DruidServerMetadata;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineLookup;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
@@ -134,7 +135,7 @@ public CachingClusteredClient(
           @Override
           public ServerView.CallbackAction segmentRemoved(DruidServerMetadata server, DataSegment segment)
           {
-            CachingClusteredClient.this.cache.close(segment.getIdentifier());
+            CachingClusteredClient.this.cache.close(segment.getId().toString());
             return ServerView.CallbackAction.CONTINUE;
           }
         }
@@ -380,7 +381,7 @@ private String computeCurrentEtag(final Set<ServerToSegment> segments, @Nullable
           hasOnlyHistoricalSegments = false;
           break;
         }
-        hasher.putString(p.getServer().getSegment().getIdentifier(), StandardCharsets.UTF_8);
+        hasher.putString(p.getServer().getSegment().getId().toString(), StandardCharsets.UTF_8);
       }
 
       if (hasOnlyHistoricalSegments) {
@@ -417,8 +418,8 @@ private List<Pair<Interval, byte[]>> pruneSegmentsWithCachedResults(
           alreadyCachedResults.add(Pair.of(segmentQueryInterval, cachedValue));
         } else if (populateCache) {
           // otherwise, if populating cache, add segment to list of segments to cache
-          final String segmentIdentifier = segment.getServer().getSegment().getIdentifier();
-          addCachePopulatorKey(segmentCacheKey, segmentIdentifier, segmentQueryInterval);
+          final SegmentId segmentId = segment.getServer().getSegment().getId();
+          addCachePopulatorKey(segmentCacheKey, segmentId, segmentQueryInterval);
         }
       });
       return alreadyCachedResults;
@@ -433,7 +434,7 @@ private Map<ServerToSegment, Cache.NamedKey> computePerSegmentCacheKeys(
       Map<ServerToSegment, Cache.NamedKey> cacheKeys = Maps.newLinkedHashMap();
       for (ServerToSegment serverToSegment : segments) {
         final Cache.NamedKey segmentCacheKey = CacheUtil.computeSegmentCacheKey(
-            serverToSegment.getServer().getSegment().getIdentifier(),
+            serverToSegment.getServer().getSegment().getId().toString(),
             serverToSegment.getSegmentDescriptor(),
             queryCacheKey
         );
@@ -453,14 +454,11 @@ private Map<Cache.NamedKey, byte[]> computeCachedValues(Map<ServerToSegment, Cac
 
     private void addCachePopulatorKey(
         Cache.NamedKey segmentCacheKey,
-        String segmentIdentifier,
+        SegmentId segmentId,
         Interval segmentQueryInterval
     )
     {
-      cachePopulatorKeyMap.put(
-          StringUtils.format("%s_%s", segmentIdentifier, segmentQueryInterval),
-          segmentCacheKey
-      );
+      cachePopulatorKeyMap.put(StringUtils.format("%s_%s", segmentId, segmentQueryInterval), segmentCacheKey);
     }
 
     @Nullable
diff --git a/server/src/main/java/org/apache/druid/client/CachingQueryRunner.java b/server/src/main/java/org/apache/druid/client/CachingQueryRunner.java
index 3a09c5c36e45..1bc5db630f1e 100644
--- a/server/src/main/java/org/apache/druid/client/CachingQueryRunner.java
+++ b/server/src/main/java/org/apache/druid/client/CachingQueryRunner.java
@@ -46,7 +46,7 @@
 
 public class CachingQueryRunner<T> implements QueryRunner<T>
 {
-  private final String segmentIdentifier;
+  private final String cacheId;
   private final SegmentDescriptor segmentDescriptor;
   private final QueryRunner<T> base;
   private final QueryToolChest toolChest;
@@ -56,7 +56,7 @@ public class CachingQueryRunner<T> implements QueryRunner<T>
   private final CacheConfig cacheConfig;
 
   public CachingQueryRunner(
-      String segmentIdentifier,
+      String cacheId,
       SegmentDescriptor segmentDescriptor,
       ObjectMapper mapper,
       Cache cache,
@@ -67,7 +67,7 @@ public CachingQueryRunner(
   )
   {
     this.base = base;
-    this.segmentIdentifier = segmentIdentifier;
+    this.cacheId = cacheId;
     this.segmentDescriptor = segmentDescriptor;
     this.toolChest = toolchest;
     this.cache = cache;
@@ -87,7 +87,7 @@ public Sequence<T> run(QueryPlus<T> queryPlus, Map<String, Object> responseConte
     final Cache.NamedKey key;
     if (strategy != null && (useCache || populateCache)) {
       key = CacheUtil.computeSegmentCacheKey(
-          segmentIdentifier,
+          cacheId,
           segmentDescriptor,
           strategy.computeCacheKey(query)
       );
diff --git a/server/src/main/java/org/apache/druid/client/CoordinatorServerView.java b/server/src/main/java/org/apache/druid/client/CoordinatorServerView.java
index c4c10185279b..ccab7c7dca44 100644
--- a/server/src/main/java/org/apache/druid/client/CoordinatorServerView.java
+++ b/server/src/main/java/org/apache/druid/client/CoordinatorServerView.java
@@ -28,6 +28,7 @@
 import org.apache.druid.query.DataSource;
 import org.apache.druid.server.coordination.DruidServerMetadata;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.PartitionChunk;
 
@@ -44,7 +45,7 @@ public class CoordinatorServerView implements InventoryView
 
   private final Object lock = new Object();
 
-  private final Map<String, SegmentLoadInfo> segmentLoadInfos;
+  private final Map<SegmentId, SegmentLoadInfo> segmentLoadInfos;
   private final Map<String, VersionedIntervalTimeline<String, SegmentLoadInfo>> timelines;
 
   private final ServerInventoryView baseView;
@@ -101,14 +102,14 @@ public ServerView.CallbackAction serverRemoved(DruidServer server)
 
   private void removeServer(DruidServer server)
   {
-    for (DataSegment segment : server.getSegments().values()) {
+    for (DataSegment segment : server.getSegments()) {
       serverRemovedSegment(server.getMetadata(), segment);
     }
   }
 
   private void serverAddedSegment(final DruidServerMetadata server, final DataSegment segment)
   {
-    String segmentId = segment.getIdentifier();
+    SegmentId segmentId = segment.getId();
     synchronized (lock) {
       log.debug("Adding segment[%s] for server[%s]", segment, server);
 
@@ -136,8 +137,7 @@ private void serverAddedSegment(final DruidServerMetadata server, final DataSegm
 
   private void serverRemovedSegment(DruidServerMetadata server, DataSegment segment)
   {
-    String segmentId = segment.getIdentifier();
-
+    SegmentId segmentId = segment.getId();
 
     synchronized (lock) {
       log.debug("Removing segment[%s] from server[%s].", segmentId, server);
@@ -181,9 +181,9 @@ public VersionedIntervalTimeline<String, SegmentLoadInfo> getTimeline(DataSource
 
 
   @Override
-  public DruidServer getInventoryValue(String string)
+  public DruidServer getInventoryValue(String serverKey)
   {
-    return baseView.getInventoryValue(string);
+    return baseView.getInventoryValue(serverKey);
   }
 
   @Override
diff --git a/server/src/main/java/org/apache/druid/client/DruidDataSource.java b/server/src/main/java/org/apache/druid/client/DruidDataSource.java
index d280e30a5b79..0d9660ae12f7 100644
--- a/server/src/main/java/org/apache/druid/client/DruidDataSource.java
+++ b/server/src/main/java/org/apache/druid/client/DruidDataSource.java
@@ -22,28 +22,38 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Preconditions;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Map;
-import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 /**
+ * A mutable collection of metadata of segments ({@link DataSegment} objects), belonging to a particular data source.
+ *
+ * Concurrency: could be updated concurrently via {@link #addSegment} and {@link
+ * #removeSegment}, and accessed concurrently (e. g. via {@link #getSegments} as well.
+ *
+ * @see ImmutableDruidDataSource - an immutable counterpart of this class
  */
 public class DruidDataSource
 {
   private final String name;
   private final Map<String, String> properties;
-  private final ConcurrentSkipListMap<String, DataSegment> idToSegmentMap;
-
-  public DruidDataSource(
-      String name,
-      Map<String, String> properties
-  )
+  /**
+   * This map needs to be concurrent because it should be possible to iterate the segments of the data source
+   * (indirectly via {@link #getSegments} or in {@link #toString}) concurrently updates via {@link #addSegment} or
+   * {@link #removeSegment}. Concurrent updates are also supported incidentally, though this is not needed for the use
+   * cases of DruidDataSource.
+   */
+  private final ConcurrentMap<SegmentId, DataSegment> idToSegmentMap = new ConcurrentHashMap<>();
+
+  public DruidDataSource(String name, Map<String, String> properties)
   {
     this.name = Preconditions.checkNotNull(name);
     this.properties = properties;
-    this.idToSegmentMap = new ConcurrentSkipListMap<>();
   }
 
   @JsonProperty
@@ -58,6 +68,11 @@ public Map<String, String> getProperties()
     return properties;
   }
 
+  public DataSegment getSegment(SegmentId segmentId)
+  {
+    return idToSegmentMap.get(segmentId);
+  }
+
   public Collection<DataSegment> getSegments()
   {
     return Collections.unmodifiableCollection(idToSegmentMap.values());
@@ -65,14 +80,26 @@ public Collection<DataSegment> getSegments()
 
   public DruidDataSource addSegment(DataSegment dataSegment)
   {
-    idToSegmentMap.put(dataSegment.getIdentifier(), dataSegment);
+    idToSegmentMap.put(dataSegment.getId(), dataSegment);
     return this;
   }
 
-  public DruidDataSource removePartition(String segmentId)
+  /**
+   * Returns true if the segment was added, false if a segment with the same {@link SegmentId} already existed in this
+   * DruidDataSource.
+   */
+  public boolean addSegmentIfAbsent(DataSegment dataSegment)
   {
-    idToSegmentMap.remove(segmentId);
-    return this;
+    return idToSegmentMap.putIfAbsent(dataSegment.getId(), dataSegment) == null;
+  }
+
+  /**
+   * Returns the removed segment, or null if there was no segment with the given {@link SegmentId} in this
+   * DruidDataSource.
+   */
+  public DataSegment removeSegment(SegmentId segmentId)
+  {
+    return idToSegmentMap.remove(segmentId);
   }
 
   public boolean isEmpty()
@@ -85,14 +112,6 @@ public ImmutableDruidDataSource toImmutableDruidDataSource()
     return new ImmutableDruidDataSource(name, properties, idToSegmentMap);
   }
 
-  // For performance reasons, make sure we check for the existence of a segment using containsSegment(),
-  // which performs a key-based lookup, instead of calling contains() on the collection returned by
-  // dataSource.getSegments(). In Map values collections, the contains() method is a linear scan.
-  public boolean containsSegment(DataSegment segment)
-  {
-    return idToSegmentMap.containsKey(segment.getIdentifier());
-  }
-
   @Override
   public String toString()
   {
diff --git a/server/src/main/java/org/apache/druid/client/DruidServer.java b/server/src/main/java/org/apache/druid/client/DruidServer.java
index 0b73f9cbaa60..ca825f62e493 100644
--- a/server/src/main/java/org/apache/druid/client/DruidServer.java
+++ b/server/src/main/java/org/apache/druid/client/DruidServer.java
@@ -21,7 +21,6 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.google.common.base.Function;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
 import org.apache.druid.java.util.common.logger.Logger;
@@ -29,16 +28,24 @@
 import org.apache.druid.server.coordination.DruidServerMetadata;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
+import javax.annotation.Nullable;
 import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 /**
+ * A mutable collection of metadata of segments ({@link DataSegment} objects), stored on a particular Druid server
+ * (typically historical).
+ *
+ * This class should not be subclassed, it isn't declared final only to make it possible to mock the class with EasyMock
+ * in tests.
+ *
+ * @see ImmutableDruidServer - an immutable counterpart of this class
  */
-public class DruidServer implements Comparable
+public class DruidServer implements Comparable<DruidServer>
 {
   public static final int DEFAULT_PRIORITY = 0;
   public static final int DEFAULT_NUM_REPLICANTS = 2;
@@ -46,20 +53,13 @@ public class DruidServer implements Comparable
 
   private static final Logger log = new Logger(DruidServer.class);
 
-  private final Object lock = new Object();
-
-  private final ConcurrentMap<String, DruidDataSource> dataSources;
-  private final ConcurrentMap<String, DataSegment> segments;
-
   private final DruidServerMetadata metadata;
 
-  private volatile long currSize;
+  private final ConcurrentHashMap<String, DruidDataSource> dataSources = new ConcurrentHashMap<>();
+  private final AtomicInteger totalSegments = new AtomicInteger();
+  private final AtomicLong currSize = new AtomicLong(0);
 
-  public DruidServer(
-      DruidNode node,
-      DruidServerConfig config,
-      ServerType type
-  )
+  public DruidServer(DruidNode node, DruidServerConfig config, ServerType type)
   {
     this(
         node.getHostAndPortToUse(),
@@ -84,9 +84,6 @@ public DruidServer(
   )
   {
     this.metadata = new DruidServerMetadata(name, hostAndPort, hostAndTlsPort, maxSize, type, tier, priority);
-
-    this.dataSources = new ConcurrentHashMap<String, DruidDataSource>();
-    this.segments = new ConcurrentHashMap<String, DataSegment>();
   }
 
   @JsonProperty
@@ -119,7 +116,7 @@ public String getHostAndTlsPort()
 
   public long getCurrSize()
   {
-    return currSize;
+    return currSize.get();
   }
 
   @JsonProperty
@@ -156,88 +153,90 @@ public String getScheme()
     return metadata.getHostAndTlsPort() != null ? "https" : "http";
   }
 
-  public Map<String, DataSegment> getSegments()
+  public Iterable<DataSegment> getSegments()
   {
-    // Copying the map slows things down a lot here, don't use Immutable Map here
-    return Collections.unmodifiableMap(segments);
+    return () -> dataSources.values().stream().flatMap(dataSource -> dataSource.getSegments().stream()).iterator();
   }
 
-  public DataSegment getSegment(String segmentName)
+  /**
+   * Returns the current number of segments, stored in this DruidServer object. This number if weakly consistent with
+   * the number of segments if {@link #getSegments} is iterated about the same time, because segments might be added or
+   * removed in parallel.
+   */
+  public int getTotalSegments()
   {
-    return segments.get(segmentName);
+    return totalSegments.get();
   }
 
-  public DruidServer addDataSegment(DataSegment segment)
+  public DataSegment getSegment(SegmentId segmentId)
   {
-    synchronized (lock) {
-      final String segmentId = segment.getIdentifier();
-      DataSegment shouldNotExist = segments.get(segmentId);
-
-      if (shouldNotExist != null) {
-        log.warn("Asked to add data segment that already exists!? server[%s], segment[%s]", getName(), segmentId);
-        return this;
-      }
-
-      String dataSourceName = segment.getDataSource();
-      DruidDataSource dataSource = dataSources.get(dataSourceName);
-
-      if (dataSource == null) {
-        dataSource = new DruidDataSource(
-            dataSourceName,
-            ImmutableMap.of("client", "side")
-        );
-        dataSources.put(dataSourceName, dataSource);
-      }
-
-      dataSource.addSegment(segment);
-
-      segments.put(segmentId, segment);
-      currSize += segment.getSize();
+    DruidDataSource dataSource = dataSources.get(segmentId.getDataSource());
+    if (dataSource == null) {
+      return null;
     }
+    return dataSource.getSegment(segmentId);
+  }
+
+  public DruidServer addDataSegment(DataSegment segment)
+  {
+    // ConcurrentHashMap.compute() ensures that all actions for specific dataSource are linearizable.
+    dataSources.compute(
+        segment.getDataSource(),
+        (dataSourceName, dataSource) -> {
+          if (dataSource == null) {
+            dataSource = new DruidDataSource(dataSourceName, ImmutableMap.of("client", "side"));
+          }
+          if (dataSource.addSegmentIfAbsent(segment)) {
+            currSize.addAndGet(segment.getSize());
+            totalSegments.incrementAndGet();
+          } else {
+            log.warn("Asked to add data segment that already exists!? server[%s], segment[%s]", getName(), segment);
+          }
+          return dataSource;
+        }
+    );
     return this;
   }
 
   public DruidServer addDataSegments(DruidServer server)
   {
-    synchronized (lock) {
-      server.segments.values().forEach(this::addDataSegment);
-    }
+    server.getSegments().forEach(this::addDataSegment);
     return this;
   }
 
-  public DruidServer removeDataSegment(String segmentId)
+  @Nullable
+  public DataSegment removeDataSegment(SegmentId segmentId)
   {
-    synchronized (lock) {
-      DataSegment segment = segments.get(segmentId);
-
-      if (segment == null) {
-        log.warn("Asked to remove data segment that doesn't exist!? server[%s], segment[%s]", getName(), segmentId);
-        return this;
-      }
-
-      DruidDataSource dataSource = dataSources.get(segment.getDataSource());
-
-      if (dataSource == null) {
-        log.warn(
-            "Asked to remove data segment from dataSource[%s] that doesn't exist, but the segment[%s] exists!?!?!?! wtf?  server[%s]",
-            segment.getDataSource(),
-            segmentId,
-            getName()
-        );
-        return this;
-      }
-
-      dataSource.removePartition(segmentId);
-
-      segments.remove(segmentId);
-      currSize -= segment.getSize();
-
-      if (dataSource.isEmpty()) {
-        dataSources.remove(dataSource.getName());
-      }
-    }
-
-    return this;
+    // To pass result from inside the lambda.
+    DataSegment[] segmentRemoved = new DataSegment[1];
+    // ConcurrentHashMap.compute() ensures that all actions for specific dataSource are linearizable.
+    dataSources.compute(
+        segmentId.getDataSource(),
+        (dataSourceName, dataSource) -> {
+          if (dataSource == null) {
+            log.warn(
+                "Asked to remove data segment from a data source that doesn't exist!? server[%s], segment[%s]",
+                getName(),
+                segmentId
+            );
+            // Returning null from the lambda here makes the ConcurrentHashMap to not record any entry.
+            //noinspection ReturnOfNull
+            return null;
+          }
+          DataSegment segment = dataSource.removeSegment(segmentId);
+          if (segment != null) {
+            segmentRemoved[0] = segment;
+            currSize.addAndGet(-segment.getSize());
+            totalSegments.decrementAndGet();
+          } else {
+            log.warn("Asked to remove data segment that doesn't exist!? server[%s], segment[%s]", getName(), segmentId);
+          }
+          // Returning null from the lambda here makes the ConcurrentHashMap to remove the current entry.
+          //noinspection ReturnOfNull
+          return dataSource.isEmpty() ? null : dataSource;
+        }
+    );
+    return segmentRemoved[0];
   }
 
   public DruidDataSource getDataSource(String dataSource)
@@ -256,17 +255,13 @@ public boolean equals(Object o)
     if (this == o) {
       return true;
     }
-    if (o == null || getClass() != o.getClass()) {
+    if (!(o instanceof DruidServer)) {
       return false;
     }
 
     DruidServer that = (DruidServer) o;
 
-    if (!metadata.equals(that.metadata)) {
-      return false;
-    }
-
-    return true;
+    return metadata.equals(that.metadata);
   }
 
   @Override
@@ -282,37 +277,23 @@ public String toString()
   }
 
   @Override
-  public int compareTo(Object o)
+  public int compareTo(DruidServer o)
   {
-    if (this == o) {
-      return 0;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return 1;
-    }
-
-    return getName().compareTo(((DruidServer) o).getName());
+    return getName().compareTo(o.getName());
   }
 
   public ImmutableDruidServer toImmutableDruidServer()
   {
-    return new ImmutableDruidServer(
-        metadata,
-        currSize,
-        ImmutableMap.copyOf(
-            Maps.transformValues(
-                dataSources,
-                new Function<DruidDataSource, ImmutableDruidDataSource>()
-                {
-                  @Override
-                  public ImmutableDruidDataSource apply(DruidDataSource input)
-                  {
-                    return input.toImmutableDruidDataSource();
-                  }
-                }
-            )
-        ),
-        ImmutableMap.copyOf(segments)
+    ImmutableMap<String, ImmutableDruidDataSource> immutableDataSources = ImmutableMap.copyOf(
+        Maps.transformValues(this.dataSources, DruidDataSource::toImmutableDruidDataSource)
     );
+    // Computing the size and the total number of segments using the resulting immutableDataSources rather that taking
+    // currSize.get() and totalSegments.get() to avoid inconsistency: segments could be added and deleted while we are
+    // running toImmutableDruidDataSource().
+    long size =
+        immutableDataSources.values().stream().mapToLong(ImmutableDruidDataSource::getTotalSizeOfSegments).sum();
+    int totalSegments =
+        immutableDataSources.values().stream().mapToInt(dataSource -> dataSource.getSegments().size()).sum();
+    return new ImmutableDruidServer(metadata, size, immutableDataSources, totalSegments);
   }
 }
diff --git a/server/src/main/java/org/apache/druid/client/HttpServerInventoryView.java b/server/src/main/java/org/apache/druid/client/HttpServerInventoryView.java
index 5705f157b0c6..e890328e1f93 100644
--- a/server/src/main/java/org/apache/druid/client/HttpServerInventoryView.java
+++ b/server/src/main/java/org/apache/druid/client/HttpServerInventoryView.java
@@ -25,6 +25,7 @@
 import com.google.common.base.Preconditions;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
+import com.google.common.collect.Collections2;
 import com.google.common.collect.Maps;
 import com.google.common.net.HostAndPort;
 import com.google.inject.Inject;
@@ -51,6 +52,7 @@
 import org.apache.druid.server.coordination.SegmentChangeRequestDrop;
 import org.apache.druid.server.coordination.SegmentChangeRequestLoad;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -67,7 +69,6 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
 
 /**
  * This class uses internal-discovery i.e. {@link DruidNodeDiscoveryProvider} to discover various queryable nodes in the cluster
@@ -276,10 +277,7 @@ public DruidServer getInventoryValue(String containerKey)
   @Override
   public Collection<DruidServer> getInventory()
   {
-    return servers.values()
-                  .stream()
-                  .map(serverHolder -> serverHolder.druidServer)
-                  .collect(Collectors.toList());
+    return Collections2.transform(servers.values(), serverHolder -> serverHolder.druidServer);
   }
 
   private void runSegmentCallbacks(
@@ -489,7 +487,7 @@ public boolean isStarted()
   public boolean isSegmentLoadedByServer(String serverKey, DataSegment segment)
   {
     DruidServerHolder holder = servers.get(serverKey);
-    return holder != null && holder.druidServer.getSegment(segment.getIdentifier()) != null;
+    return holder != null && holder.druidServer.getSegment(segment.getId()) != null;
   }
 
   private class DruidServerHolder
@@ -534,7 +532,7 @@ void stop()
     boolean isSyncedSuccessfullyAtleastOnce()
     {
       try {
-        return syncer.awaitInitialization(1);
+        return syncer.awaitInitialization(1, TimeUnit.MILLISECONDS);
       }
       catch (InterruptedException ex) {
         throw new RE(
@@ -552,12 +550,13 @@ private ChangeRequestHttpSyncer.Listener<DataSegmentChangeRequest> createSyncLis
         @Override
         public void fullSync(List<DataSegmentChangeRequest> changes)
         {
-          Map<String, DataSegment> toRemove = Maps.newHashMap(druidServer.getSegments());
+          Map<SegmentId, DataSegment> toRemove = Maps.newHashMapWithExpectedSize(druidServer.getTotalSegments());
+          druidServer.getSegments().forEach(segment -> toRemove.put(segment.getId(), segment));
 
           for (DataSegmentChangeRequest request : changes) {
             if (request instanceof SegmentChangeRequestLoad) {
               DataSegment segment = ((SegmentChangeRequestLoad) request).getSegment();
-              toRemove.remove(segment.getIdentifier());
+              toRemove.remove(segment.getId());
               addSegment(segment);
             } else {
               log.error(
@@ -596,7 +595,7 @@ public void deltaSync(List<DataSegmentChangeRequest> changes)
     private void addSegment(final DataSegment segment)
     {
       if (finalPredicate.apply(Pair.of(druidServer.getMetadata(), segment))) {
-        if (druidServer.getSegment(segment.getIdentifier()) == null) {
+        if (druidServer.getSegment(segment.getId()) == null) {
           druidServer.addDataSegment(segment);
           runSegmentCallbacks(
               new Function<SegmentCallback, CallbackAction>()
@@ -611,7 +610,7 @@ public CallbackAction apply(SegmentCallback input)
         } else {
           log.warn(
               "Not adding or running callbacks for existing segment[%s] on server[%s]",
-              segment.getIdentifier(),
+              segment.getId(),
               druidServer.getName()
           );
         }
@@ -620,9 +619,7 @@ public CallbackAction apply(SegmentCallback input)
 
     private void removeSegment(final DataSegment segment)
     {
-      if (druidServer.getSegment(segment.getIdentifier()) != null) {
-        druidServer.removeDataSegment(segment.getIdentifier());
-
+      if (druidServer.removeDataSegment(segment.getId()) != null) {
         runSegmentCallbacks(
             new Function<SegmentCallback, CallbackAction>()
             {
@@ -636,7 +633,7 @@ public CallbackAction apply(SegmentCallback input)
       } else {
         log.warn(
             "Not running cleanup or callbacks for non-existing segment[%s] on server[%s]",
-            segment.getIdentifier(),
+            segment.getId(),
             druidServer.getName()
         );
       }
diff --git a/server/src/main/java/org/apache/druid/client/ImmutableDruidDataSource.java b/server/src/main/java/org/apache/druid/client/ImmutableDruidDataSource.java
index 66b006465416..59539443b618 100644
--- a/server/src/main/java/org/apache/druid/client/ImmutableDruidDataSource.java
+++ b/server/src/main/java/org/apache/druid/client/ImmutableDruidDataSource.java
@@ -26,29 +26,34 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSortedMap;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 import java.util.Collection;
 import java.util.Map;
 import java.util.Objects;
-import java.util.SortedMap;
 
 /**
+ * An immutable collection of metadata of segments ({@link DataSegment} objects), belonging to a particular data source.
+ *
+ * @see DruidDataSource - a mutable counterpart of this class
  */
 public class ImmutableDruidDataSource
 {
   private final String name;
   private final ImmutableMap<String, String> properties;
-  private final ImmutableSortedMap<String, DataSegment> idToSegments;
-
-  public ImmutableDruidDataSource(
-      String name,
-      Map<String, String> properties,
-      SortedMap<String, DataSegment> idToSegments
-  )
+  private final ImmutableSortedMap<SegmentId, DataSegment> idToSegments;
+  private final long totalSizeOfSegments;
+
+  /**
+   * Concurrency: idToSegments argument might be a {@link java.util.concurrent.ConcurrentMap} that is being updated
+   * concurrently while this constructor is executed.
+   */
+  public ImmutableDruidDataSource(String name, Map<String, String> properties, Map<SegmentId, DataSegment> idToSegments)
   {
     this.name = Preconditions.checkNotNull(name);
     this.properties = ImmutableMap.copyOf(properties);
-    this.idToSegments = ImmutableSortedMap.copyOfSorted(idToSegments);
+    this.idToSegments = ImmutableSortedMap.copyOf(idToSegments);
+    this.totalSizeOfSegments = idToSegments.values().stream().mapToLong(DataSegment::getSize).sum();
   }
 
   @JsonCreator
@@ -60,9 +65,15 @@ public ImmutableDruidDataSource(
   {
     this.name = Preconditions.checkNotNull(name);
     this.properties = ImmutableMap.copyOf(properties);
-    final ImmutableSortedMap.Builder<String, DataSegment> builder = ImmutableSortedMap.naturalOrder();
-    segments.forEach(segment -> builder.put(segment.getIdentifier(), segment));
-    this.idToSegments = builder.build();
+
+    final ImmutableSortedMap.Builder<SegmentId, DataSegment> idToSegmentsBuilder = ImmutableSortedMap.naturalOrder();
+    long totalSizeOfSegments = 0;
+    for (DataSegment segment : segments) {
+      idToSegmentsBuilder.put(segment.getId(), segment);
+      totalSizeOfSegments += segment.getSize();
+    }
+    this.idToSegments = idToSegmentsBuilder.build();
+    this.totalSizeOfSegments = totalSizeOfSegments;
   }
 
   @JsonProperty
@@ -84,9 +95,18 @@ public Collection<DataSegment> getSegments()
   }
 
   @JsonIgnore
-  public DataSegment getSegment(String segmentIdentifier)
+  public DataSegment getSegment(SegmentId segmentId)
+  {
+    return idToSegments.get(segmentId);
+  }
+
+  /**
+   * Returns the sum of the {@link DataSegment#getSize() sizes} of all segments in this ImmutableDruidDataSource.
+   */
+  @JsonIgnore
+  public long getTotalSizeOfSegments()
   {
-    return idToSegments.get(segmentIdentifier);
+    return totalSizeOfSegments;
   }
 
   @Override
diff --git a/server/src/main/java/org/apache/druid/client/ImmutableDruidServer.java b/server/src/main/java/org/apache/druid/client/ImmutableDruidServer.java
index 5426d793d9d0..be54c7caac2a 100644
--- a/server/src/main/java/org/apache/druid/client/ImmutableDruidServer.java
+++ b/server/src/main/java/org/apache/druid/client/ImmutableDruidServer.java
@@ -25,29 +25,36 @@
 import org.apache.druid.server.coordination.DruidServerMetadata;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
-import java.util.Map;
+import java.util.AbstractCollection;
+import java.util.Collection;
+import java.util.Iterator;
 
 /**
+ * This class should not be subclassed, it isn't declared final only to make it possible to mock the class with EasyMock
+ * in tests.
+ *
+ * @see DruidServer - a mutable counterpart of this class
  */
 public class ImmutableDruidServer
 {
   private final DruidServerMetadata metadata;
   private final long currSize;
   private final ImmutableMap<String, ImmutableDruidDataSource> dataSources;
-  private final ImmutableMap<String, DataSegment> segments;
+  private final int totalSegments;
 
   public ImmutableDruidServer(
       DruidServerMetadata metadata,
       long currSize,
       ImmutableMap<String, ImmutableDruidDataSource> dataSources,
-      ImmutableMap<String, DataSegment> segments
+      int totalSegments
   )
   {
     this.metadata = Preconditions.checkNotNull(metadata);
     this.currSize = currSize;
-    this.segments = segments;
     this.dataSources = dataSources;
+    this.totalSegments = totalSegments;
   }
 
   public String getName()
@@ -90,9 +97,13 @@ public int getPriority()
     return metadata.getPriority();
   }
 
-  public DataSegment getSegment(String segmentName)
+  public DataSegment getSegment(SegmentId segmentId)
   {
-    return segments.get(segmentName);
+    ImmutableDruidDataSource dataSource = dataSources.get(segmentId.getDataSource());
+    if (dataSource == null) {
+      return null;
+    }
+    return dataSource.getSegment(segmentId);
   }
 
   public Iterable<ImmutableDruidDataSource> getDataSources()
@@ -105,9 +116,22 @@ public ImmutableDruidDataSource getDataSource(String name)
     return dataSources.get(name);
   }
 
-  public Map<String, DataSegment> getSegments()
+  public Collection<DataSegment> getSegments()
   {
-    return segments;
+    return new AbstractCollection<DataSegment>()
+    {
+      @Override
+      public Iterator<DataSegment> iterator()
+      {
+        return dataSources.values().stream().flatMap(dataSource -> dataSource.getSegments().stream()).iterator();
+      }
+
+      @Override
+      public int size()
+      {
+        return totalSegments;
+      }
+    };
   }
 
   public String getURL()
diff --git a/server/src/main/java/org/apache/druid/client/InventoryView.java b/server/src/main/java/org/apache/druid/client/InventoryView.java
index 6d09b7b362f6..f145144e2004 100644
--- a/server/src/main/java/org/apache/druid/client/InventoryView.java
+++ b/server/src/main/java/org/apache/druid/client/InventoryView.java
@@ -21,13 +21,15 @@
 
 import org.apache.druid.timeline.DataSegment;
 
+import javax.annotation.Nullable;
 import java.util.Collection;
 
 /**
  */
 public interface InventoryView
 {
-  DruidServer getInventoryValue(String string);
+  @Nullable
+  DruidServer getInventoryValue(String serverKey);
   Collection<DruidServer> getInventory();
   boolean isStarted();
   boolean isSegmentLoadedByServer(String serverKey, DataSegment segment);
diff --git a/server/src/main/java/org/apache/druid/curator/inventory/CuratorInventoryManager.java b/server/src/main/java/org/apache/druid/curator/inventory/CuratorInventoryManager.java
index 38a49d5ee5a0..bf6c7c670006 100644
--- a/server/src/main/java/org/apache/druid/curator/inventory/CuratorInventoryManager.java
+++ b/server/src/main/java/org/apache/druid/curator/inventory/CuratorInventoryManager.java
@@ -20,18 +20,18 @@
 package org.apache.druid.curator.inventory;
 
 import com.google.common.collect.Sets;
-import org.apache.druid.curator.cache.PathChildrenCacheFactory;
-import org.apache.druid.java.util.common.StringUtils;
-import org.apache.druid.java.util.common.io.Closer;
-import org.apache.druid.java.util.common.lifecycle.LifecycleStart;
-import org.apache.druid.java.util.common.lifecycle.LifecycleStop;
-import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.curator.framework.CuratorFramework;
 import org.apache.curator.framework.recipes.cache.ChildData;
 import org.apache.curator.framework.recipes.cache.PathChildrenCache;
 import org.apache.curator.framework.recipes.cache.PathChildrenCacheEvent;
 import org.apache.curator.framework.recipes.cache.PathChildrenCacheListener;
 import org.apache.curator.utils.ZKPaths;
+import org.apache.druid.curator.cache.PathChildrenCacheFactory;
+import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.io.Closer;
+import org.apache.druid.java.util.common.lifecycle.LifecycleStart;
+import org.apache.druid.java.util.common.lifecycle.LifecycleStop;
+import org.apache.druid.java.util.common.logger.Logger;
 
 import java.io.IOException;
 import java.util.Collection;
@@ -264,7 +264,7 @@ public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) th
 
             final ContainerHolder removed = containers.remove(containerKey);
             if (removed == null) {
-              log.warn("Container[%s] removed that wasn't a container!?", child.getPath());
+              log.error("Container[%s] removed that wasn't a container!?", child.getPath());
               break;
             }
 
@@ -287,10 +287,12 @@ public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) th
 
             byte[] data = getZkDataForNode(child.getPath());
             if (data == null) {
-              log.info("Ignoring event: Type - %s , Path - %s , Version - %s",
+              log.info(
+                  "Ignoring event: Type - %s , Path - %s , Version - %s",
                   event.getType(),
                   child.getPath(),
-                  child.getStat().getVersion());
+                  child.getStat().getVersion()
+              );
               return;
             }
 
@@ -301,7 +303,7 @@ public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) th
             log.debug("Container[%s] updated.", child.getPath());
             ContainerHolder holder = containers.get(containerKey);
             if (holder == null) {
-              log.warn("Container update[%s], but the old container didn't exist!?  Ignoring.", child.getPath());
+              log.error("Container update[%s], but the old container didn't exist!?  Ignoring.", child.getPath());
             } else {
               synchronized (holder) {
                 holder.setContainer(strategy.updateContainer(holder.getContainer(), container));
@@ -311,7 +313,7 @@ public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) th
           break;
         case INITIALIZED:
           synchronized (lock) {
-            // must await initialized of all containerholders
+            // must await initialized of all container holders
             for (ContainerHolder holder : containers.values()) {
               synchronized (holder) {
                 if (!holder.initialized) {
diff --git a/server/src/main/java/org/apache/druid/curator/inventory/CuratorInventoryManagerStrategy.java b/server/src/main/java/org/apache/druid/curator/inventory/CuratorInventoryManagerStrategy.java
index cfe3b394e1e5..2a1d79c4a51d 100644
--- a/server/src/main/java/org/apache/druid/curator/inventory/CuratorInventoryManagerStrategy.java
+++ b/server/src/main/java/org/apache/druid/curator/inventory/CuratorInventoryManagerStrategy.java
@@ -20,6 +20,10 @@
 package org.apache.druid.curator.inventory;
 
 /**
+ * Concurrency guarantees: all calls to {@link #newContainer}, {@link #deadContainer}, {@link #updateContainer} and
+ * {@link #inventoryInitialized} (all done within {@link CuratorInventoryManager#pathChildrenCacheExecutor}) are
+ * linearizable. Calls to {@link #addInventory}, {@link #updateInventory} and {@link #removeInventory} are linearizable
+ * for the each container in independence.
  */
 public interface CuratorInventoryManagerStrategy<ContainerClass, InventoryClass>
 {
diff --git a/server/src/main/java/org/apache/druid/discovery/DiscoveryDruidNode.java b/server/src/main/java/org/apache/druid/discovery/DiscoveryDruidNode.java
index fbb124afd2b2..98d389a63a97 100644
--- a/server/src/main/java/org/apache/druid/discovery/DiscoveryDruidNode.java
+++ b/server/src/main/java/org/apache/druid/discovery/DiscoveryDruidNode.java
@@ -21,6 +21,7 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import org.apache.druid.client.DruidServer;
 import org.apache.druid.server.DruidNode;
 
 import java.util.HashMap;
@@ -75,6 +76,19 @@ public DruidNode getDruidNode()
     return druidNode;
   }
 
+  public DruidServer toDruidServer()
+  {
+    return new DruidServer(
+        getDruidNode().getHostAndPortToUse(),
+        getDruidNode().getHostAndPort(),
+        getDruidNode().getHostAndTlsPort(),
+        ((DataNodeService) getServices().get(DataNodeService.DISCOVERY_SERVICE_KEY)).getMaxSize(),
+        ((DataNodeService) getServices().get(DataNodeService.DISCOVERY_SERVICE_KEY)).getType(),
+        ((DataNodeService) getServices().get(DataNodeService.DISCOVERY_SERVICE_KEY)).getTier(),
+        ((DataNodeService) getServices().get(DataNodeService.DISCOVERY_SERVICE_KEY)).getPriority()
+    );
+  }
+
   @Override
   public boolean equals(Object o)
   {
diff --git a/server/src/main/java/org/apache/druid/indexer/SQLMetadataStorageUpdaterJobHandler.java b/server/src/main/java/org/apache/druid/indexer/SQLMetadataStorageUpdaterJobHandler.java
index 4ba15d568119..c3728762979b 100644
--- a/server/src/main/java/org/apache/druid/indexer/SQLMetadataStorageUpdaterJobHandler.java
+++ b/server/src/main/java/org/apache/druid/indexer/SQLMetadataStorageUpdaterJobHandler.java
@@ -68,7 +68,7 @@ public Void withHandle(Handle handle) throws Exception
 
               batch.add(
                   new ImmutableMap.Builder<String, Object>()
-                      .put("id", segment.getIdentifier())
+                      .put("id", segment.getId())
                       .put("dataSource", segment.getDataSource())
                       .put("created_date", DateTimes.nowUtc().toString())
                       .put("start", segment.getInterval().getStart().toString())
@@ -80,7 +80,7 @@ public Void withHandle(Handle handle) throws Exception
                       .build()
               );
 
-              log.info("Published %s", segment.getIdentifier());
+              log.info("Published %s", segment.getId());
 
             }
             batch.execute();
diff --git a/server/src/main/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageCoordinator.java b/server/src/main/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageCoordinator.java
index c58f2749c508..95c1fce15c6e 100644
--- a/server/src/main/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageCoordinator.java
+++ b/server/src/main/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageCoordinator.java
@@ -20,7 +20,7 @@
 package org.apache.druid.indexing.overlord;
 
 import org.apache.druid.java.util.common.Pair;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Interval;
 
@@ -100,7 +100,7 @@ default List<DataSegment> getUsedSegmentsForInterval(String dataSource, Interval
    *
    * @return the pending segment identifier, or null if it was impossible to allocate a new segment
    */
-  SegmentIdentifier allocatePendingSegment(
+  SegmentIdWithShardSpec allocatePendingSegment(
       String dataSource,
       String sequenceName,
       String previousSegmentId,
diff --git a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
index d021e4b1f26b..b9064fdc739b 100644
--- a/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
+++ b/server/src/main/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinator.java
@@ -44,7 +44,7 @@
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.lifecycle.LifecycleStart;
 import org.apache.druid.java.util.common.logger.Logger;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
@@ -166,13 +166,13 @@ public Iterable<DataSegment> apply(TimelineObjectHolder<String, DataSegment> inp
     );
   }
 
-  private List<SegmentIdentifier> getPendingSegmentsForIntervalWithHandle(
+  private List<SegmentIdWithShardSpec> getPendingSegmentsForIntervalWithHandle(
       final Handle handle,
       final String dataSource,
       final Interval interval
   ) throws IOException
   {
-    final List<SegmentIdentifier> identifiers = Lists.newArrayList();
+    final List<SegmentIdWithShardSpec> identifiers = Lists.newArrayList();
 
     final ResultIterator<byte[]> dbSegments =
         handle.createQuery(
@@ -189,7 +189,7 @@ private List<SegmentIdentifier> getPendingSegmentsForIntervalWithHandle(
 
     while (dbSegments.hasNext()) {
       final byte[] payload = dbSegments.next();
-      final SegmentIdentifier identifier = jsonMapper.readValue(payload, SegmentIdentifier.class);
+      final SegmentIdWithShardSpec identifier = jsonMapper.readValue(payload, SegmentIdWithShardSpec.class);
 
       if (interval.overlaps(identifier.getInterval())) {
         identifiers.add(identifier);
@@ -373,7 +373,7 @@ public SegmentPublishResult inTransaction(
   }
 
   @Override
-  public SegmentIdentifier allocatePendingSegment(
+  public SegmentIdWithShardSpec allocatePendingSegment(
       final String dataSource,
       final String sequenceName,
       @Nullable final String previousSegmentId,
@@ -388,10 +388,10 @@ public SegmentIdentifier allocatePendingSegment(
     Preconditions.checkNotNull(maxVersion, "maxVersion");
 
     return connector.retryTransaction(
-        new TransactionCallback<SegmentIdentifier>()
+        new TransactionCallback<SegmentIdWithShardSpec>()
         {
           @Override
-          public SegmentIdentifier inTransaction(Handle handle, TransactionStatus transactionStatus) throws Exception
+          public SegmentIdWithShardSpec inTransaction(Handle handle, TransactionStatus transactionStatus) throws Exception
           {
             return skipSegmentLineageCheck ?
                    allocatePendingSegment(handle, dataSource, sequenceName, interval, maxVersion) :
@@ -411,7 +411,7 @@ public SegmentIdentifier inTransaction(Handle handle, TransactionStatus transact
   }
 
   @Nullable
-  private SegmentIdentifier allocatePendingSegmentWithSegmentLineageCheck(
+  private SegmentIdWithShardSpec allocatePendingSegmentWithSegmentLineageCheck(
       final Handle handle,
       final String dataSource,
       final String sequenceName,
@@ -444,7 +444,7 @@ private SegmentIdentifier allocatePendingSegmentWithSegmentLineageCheck(
       return result.segmentIdentifier;
     }
 
-    final SegmentIdentifier newIdentifier = createNewSegment(handle, dataSource, interval, maxVersion);
+    final SegmentIdWithShardSpec newIdentifier = createNewSegment(handle, dataSource, interval, maxVersion);
     if (newIdentifier == null) {
       return null;
     }
@@ -479,7 +479,7 @@ private SegmentIdentifier allocatePendingSegmentWithSegmentLineageCheck(
   }
 
   @Nullable
-  private SegmentIdentifier allocatePendingSegment(
+  private SegmentIdWithShardSpec allocatePendingSegment(
       final Handle handle,
       final String dataSource,
       final String sequenceName,
@@ -513,7 +513,7 @@ private SegmentIdentifier allocatePendingSegment(
       return result.segmentIdentifier;
     }
 
-    final SegmentIdentifier newIdentifier = createNewSegment(handle, dataSource, interval, maxVersion);
+    final SegmentIdWithShardSpec newIdentifier = createNewSegment(handle, dataSource, interval, maxVersion);
     if (newIdentifier == null) {
       return null;
     }
@@ -539,11 +539,7 @@ private SegmentIdentifier allocatePendingSegment(
     // always insert empty previous sequence id
     insertToMetastore(handle, newIdentifier, dataSource, interval, "", sequenceName, sequenceNamePrevIdSha1);
 
-    log.info(
-        "Allocated pending segment [%s] for sequence[%s] in DB",
-        newIdentifier.getIdentifierAsString(),
-        sequenceName
-    );
+    log.info("Allocated pending segment [%s] for sequence[%s] in DB", newIdentifier, sequenceName);
 
     return newIdentifier;
   }
@@ -563,23 +559,19 @@ private CheckExistingSegmentIdResult checkAndGetExistingSegmentId(
     final List<byte[]> existingBytes = boundQuery.map(ByteArrayMapper.FIRST).list();
 
     if (!existingBytes.isEmpty()) {
-      final SegmentIdentifier existingIdentifier = jsonMapper.readValue(
+      final SegmentIdWithShardSpec existingIdentifier = jsonMapper.readValue(
           Iterables.getOnlyElement(existingBytes),
-          SegmentIdentifier.class
+          SegmentIdWithShardSpec.class
       );
 
       if (existingIdentifier.getInterval().getStartMillis() == interval.getStartMillis()
           && existingIdentifier.getInterval().getEndMillis() == interval.getEndMillis()) {
         if (previousSegmentId == null) {
-          log.info(
-              "Found existing pending segment [%s] for sequence[%s] in DB",
-              existingIdentifier.getIdentifierAsString(),
-              sequenceName
-          );
+          log.info("Found existing pending segment [%s] for sequence[%s] in DB", existingIdentifier, sequenceName);
         } else {
           log.info(
               "Found existing pending segment [%s] for sequence[%s] (previous = [%s]) in DB",
-              existingIdentifier.getIdentifierAsString(),
+              existingIdentifier,
               sequenceName,
               previousSegmentId
           );
@@ -591,7 +583,7 @@ private CheckExistingSegmentIdResult checkAndGetExistingSegmentId(
           log.warn(
               "Cannot use existing pending segment [%s] for sequence[%s] in DB, "
               + "does not match requested interval[%s]",
-              existingIdentifier.getIdentifierAsString(),
+              existingIdentifier,
               sequenceName,
               interval
           );
@@ -599,7 +591,7 @@ private CheckExistingSegmentIdResult checkAndGetExistingSegmentId(
           log.warn(
               "Cannot use existing pending segment [%s] for sequence[%s] (previous = [%s]) in DB, "
               + "does not match requested interval[%s]",
-              existingIdentifier.getIdentifierAsString(),
+              existingIdentifier,
               sequenceName,
               previousSegmentId,
               interval
@@ -616,9 +608,9 @@ private static class CheckExistingSegmentIdResult
   {
     private final boolean found;
     @Nullable
-    private final SegmentIdentifier segmentIdentifier;
+    private final SegmentIdWithShardSpec segmentIdentifier;
 
-    CheckExistingSegmentIdResult(boolean found, @Nullable SegmentIdentifier segmentIdentifier)
+    CheckExistingSegmentIdResult(boolean found, @Nullable SegmentIdWithShardSpec segmentIdentifier)
     {
       this.found = found;
       this.segmentIdentifier = segmentIdentifier;
@@ -627,7 +619,7 @@ private static class CheckExistingSegmentIdResult
 
   private void insertToMetastore(
       Handle handle,
-      SegmentIdentifier newIdentifier,
+      SegmentIdWithShardSpec newIdentifier,
       String dataSource,
       Interval interval,
       String previousSegmentId,
@@ -643,7 +635,7 @@ private void insertToMetastore(
             connector.getQuoteString()
         )
     )
-          .bind("id", newIdentifier.getIdentifierAsString())
+          .bind("id", newIdentifier.toString())
           .bind("dataSource", dataSource)
           .bind("created_date", DateTimes.nowUtc().toString())
           .bind("start", interval.getStart().toString())
@@ -656,7 +648,7 @@ private void insertToMetastore(
   }
 
   @Nullable
-  private SegmentIdentifier createNewSegment(
+  private SegmentIdWithShardSpec createNewSegment(
       final Handle handle,
       final String dataSource,
       final Interval interval,
@@ -684,65 +676,64 @@ private SegmentIdentifier createNewSegment(
       );
       return null;
     } else {
-      SegmentIdentifier max = null;
+      SegmentIdWithShardSpec maxId = null;
 
       if (!existingChunks.isEmpty()) {
         TimelineObjectHolder<String, DataSegment> existingHolder = Iterables.getOnlyElement(existingChunks);
         for (PartitionChunk<DataSegment> existing : existingHolder.getObject()) {
-          if (max == null || max.getShardSpec().getPartitionNum() < existing.getObject()
-                                                                            .getShardSpec()
-                                                                            .getPartitionNum()) {
-            max = SegmentIdentifier.fromDataSegment(existing.getObject());
+          if (maxId == null ||
+              maxId.getShardSpec().getPartitionNum() < existing.getObject().getShardSpec().getPartitionNum()) {
+            maxId = SegmentIdWithShardSpec.fromDataSegment(existing.getObject());
           }
         }
       }
 
-      final List<SegmentIdentifier> pendings = getPendingSegmentsForIntervalWithHandle(
+      final List<SegmentIdWithShardSpec> pendings = getPendingSegmentsForIntervalWithHandle(
           handle,
           dataSource,
           interval
       );
 
-      for (SegmentIdentifier pending : pendings) {
-        if (max == null ||
-            pending.getVersion().compareTo(max.getVersion()) > 0 ||
-            (pending.getVersion().equals(max.getVersion())
-             && pending.getShardSpec().getPartitionNum() > max.getShardSpec().getPartitionNum())) {
-          max = pending;
+      for (SegmentIdWithShardSpec pending : pendings) {
+        if (maxId == null ||
+            pending.getVersion().compareTo(maxId.getVersion()) > 0 ||
+            (pending.getVersion().equals(maxId.getVersion())
+             && pending.getShardSpec().getPartitionNum() > maxId.getShardSpec().getPartitionNum())) {
+          maxId = pending;
         }
       }
 
-      if (max == null) {
-        return new SegmentIdentifier(
+      if (maxId == null) {
+        return new SegmentIdWithShardSpec(
             dataSource,
             interval,
             maxVersion,
             new NumberedShardSpec(0, 0)
         );
-      } else if (!max.getInterval().equals(interval) || max.getVersion().compareTo(maxVersion) > 0) {
+      } else if (!maxId.getInterval().equals(interval) || maxId.getVersion().compareTo(maxVersion) > 0) {
         log.warn(
             "Cannot allocate new segment for dataSource[%s], interval[%s], maxVersion[%s]: conflicting segment[%s].",
             dataSource,
             interval,
             maxVersion,
-            max.getIdentifierAsString()
+            maxId
         );
         return null;
-      } else if (max.getShardSpec() instanceof LinearShardSpec) {
-        return new SegmentIdentifier(
+      } else if (maxId.getShardSpec() instanceof LinearShardSpec) {
+        return new SegmentIdWithShardSpec(
             dataSource,
-            max.getInterval(),
-            max.getVersion(),
-            new LinearShardSpec(max.getShardSpec().getPartitionNum() + 1)
+            maxId.getInterval(),
+            maxId.getVersion(),
+            new LinearShardSpec(maxId.getShardSpec().getPartitionNum() + 1)
         );
-      } else if (max.getShardSpec() instanceof NumberedShardSpec) {
-        return new SegmentIdentifier(
+      } else if (maxId.getShardSpec() instanceof NumberedShardSpec) {
+        return new SegmentIdWithShardSpec(
             dataSource,
-            max.getInterval(),
-            max.getVersion(),
+            maxId.getInterval(),
+            maxId.getVersion(),
             new NumberedShardSpec(
-                max.getShardSpec().getPartitionNum() + 1,
-                ((NumberedShardSpec) max.getShardSpec()).getPartitions()
+                maxId.getShardSpec().getPartitionNum() + 1,
+                ((NumberedShardSpec) maxId.getShardSpec()).getPartitions()
             )
         );
       } else {
@@ -751,8 +742,8 @@ private SegmentIdentifier createNewSegment(
             dataSource,
             interval,
             maxVersion,
-            max.getShardSpec().getClass(),
-            max.getIdentifierAsString()
+            maxId.getShardSpec().getClass(),
+            maxId
         );
         return null;
       }
@@ -791,7 +782,7 @@ private boolean announceHistoricalSegment(
   {
     try {
       if (segmentExists(handle, segment)) {
-        log.info("Found [%s] in DB, not updating DB", segment.getIdentifier());
+        log.info("Found [%s] in DB, not updating DB", segment.getId());
         return false;
       }
 
@@ -806,7 +797,7 @@ private boolean announceHistoricalSegment(
               connector.getQuoteString()
           )
       )
-            .bind("id", segment.getIdentifier())
+            .bind("id", segment.getId().toString())
             .bind("dataSource", segment.getDataSource())
             .bind("created_date", DateTimes.nowUtc().toString())
             .bind("start", segment.getInterval().getStart().toString())
@@ -817,10 +808,10 @@ private boolean announceHistoricalSegment(
             .bind("payload", jsonMapper.writeValueAsBytes(segment))
             .execute();
 
-      log.info("Published segment [%s] to DB with used flag [%s]", segment.getIdentifier(), used);
+      log.info("Published segment [%s] to DB with used flag [%s]", segment.getId(), used);
     }
     catch (Exception e) {
-      log.error(e, "Exception inserting segment [%s] with used flag [%s] into DB", segment.getIdentifier(), used);
+      log.error(e, "Exception inserting segment [%s] with used flag [%s] into DB", segment.getId(), used);
       throw e;
     }
 
@@ -830,12 +821,8 @@ private boolean announceHistoricalSegment(
   private boolean segmentExists(final Handle handle, final DataSegment segment)
   {
     return !handle
-        .createQuery(
-            StringUtils.format(
-                "SELECT id FROM %s WHERE id = :identifier",
-                dbTables.getSegmentsTable()
-            )
-        ).bind("identifier", segment.getIdentifier())
+        .createQuery(StringUtils.format("SELECT id FROM %s WHERE id = :identifier", dbTables.getSegmentsTable()))
+        .bind("identifier", segment.getId().toString())
         .map(StringMapper.FIRST)
         .list()
         .isEmpty();
@@ -1088,22 +1075,21 @@ public Void inTransaction(Handle handle, TransactionStatus transactionStatus)
 
   private void deleteSegment(final Handle handle, final DataSegment segment)
   {
-    handle.createStatement(
-        StringUtils.format("DELETE from %s WHERE id = :id", dbTables.getSegmentsTable())
-    )
-          .bind("id", segment.getIdentifier())
+    handle.createStatement(StringUtils.format("DELETE from %s WHERE id = :id", dbTables.getSegmentsTable()))
+          .bind("id", segment.getId().toString())
           .execute();
   }
 
   private void updatePayload(final Handle handle, final DataSegment segment) throws IOException
   {
     try {
-      handle.createStatement(
-          StringUtils.format("UPDATE %s SET payload = :payload WHERE id = :id", dbTables.getSegmentsTable())
-      )
-            .bind("id", segment.getIdentifier())
-            .bind("payload", jsonMapper.writeValueAsBytes(segment))
-            .execute();
+      handle
+          .createStatement(
+              StringUtils.format("UPDATE %s SET payload = :payload WHERE id = :id", dbTables.getSegmentsTable())
+          )
+          .bind("id", segment.getId().toString())
+          .bind("payload", jsonMapper.writeValueAsBytes(segment))
+          .execute();
     }
     catch (IOException e) {
       log.error(e, "Exception inserting into DB");
diff --git a/server/src/main/java/org/apache/druid/metadata/MetadataSegmentManager.java b/server/src/main/java/org/apache/druid/metadata/MetadataSegmentManager.java
index 5c93e803bc99..195ae13998cb 100644
--- a/server/src/main/java/org/apache/druid/metadata/MetadataSegmentManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/MetadataSegmentManager.java
@@ -19,7 +19,9 @@
 
 package org.apache.druid.metadata;
 
+import com.google.common.annotations.VisibleForTesting;
 import org.apache.druid.client.ImmutableDruidDataSource;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 import javax.annotation.Nullable;
@@ -28,38 +30,39 @@
 
 /**
  */
-
 public interface MetadataSegmentManager
 {
   void start();
 
   void stop();
 
-  boolean enableDatasource(String ds);
+  boolean enableDataSource(String dataSource);
 
   boolean enableSegment(String segmentId);
 
-  boolean removeDatasource(String ds);
+  boolean removeDataSource(String dataSource);
+
+  /**
+   * Prefer {@link #removeSegment(SegmentId)} to this method when possible.
+   */
+  boolean removeSegment(String dataSource, String segmentId);
 
-  boolean removeSegment(String ds, String segmentID);
+  boolean removeSegment(SegmentId segmentId);
 
   boolean isStarted();
 
   @Nullable
-  ImmutableDruidDataSource getInventoryValue(String key);
+  ImmutableDruidDataSource getDataSource(String dataSourceName);
 
-  Collection<ImmutableDruidDataSource> getInventory();
+  Collection<ImmutableDruidDataSource> getDataSources();
 
-  Collection<String> getAllDatasourceNames();
+  Collection<String> getAllDataSourceNames();
 
   /**
    * Returns top N unused segment intervals in given interval when ordered by segment start time, end time.
    */
-  List<Interval> getUnusedSegmentIntervals(
-      String dataSource,
-      Interval interval,
-      int limit
-  );
+  List<Interval> getUnusedSegmentIntervals(String dataSource, Interval interval, int limit);
 
+  @VisibleForTesting
   void poll();
 }
diff --git a/server/src/main/java/org/apache/druid/metadata/SQLMetadataRuleManager.java b/server/src/main/java/org/apache/druid/metadata/SQLMetadataRuleManager.java
index b1eb9f5aa427..6174e89d1f45 100644
--- a/server/src/main/java/org/apache/druid/metadata/SQLMetadataRuleManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/SQLMetadataRuleManager.java
@@ -200,7 +200,7 @@ public void start()
             public void run()
             {
               try {
-                // poll() is synchronized together with start() and stop() to ensure that when stop() exists, poll()
+                // poll() is synchronized together with start() and stop() to ensure that when stop() exits, poll()
                 // won't actually run anymore after that (it could only enter the syncrhonized section and exit
                 // immediately because the localStartedOrder doesn't match the new currentStartOrder). It's needed
                 // to avoid flakiness in SQLMetadataRuleManagerTest.
diff --git a/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java b/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
index c072ee6717d5..200db784a35f 100644
--- a/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
@@ -20,10 +20,8 @@
 package org.apache.druid.metadata;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.base.Predicates;
 import com.google.common.base.Supplier;
 import com.google.common.base.Throwables;
-import com.google.common.collect.Collections2;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Interner;
 import com.google.common.collect.Interners;
@@ -42,6 +40,7 @@
 import org.apache.druid.java.util.common.lifecycle.LifecycleStop;
 import org.apache.druid.java.util.emitter.EmittingLogger;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.PartitionChunk;
@@ -69,11 +68,10 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.stream.Collectors;
 
@@ -90,18 +88,26 @@ public class SQLMetadataSegmentManager implements MetadataSegmentManager
    * should be synchronized to prevent from being called at the same time if two different threads are calling them.
    * This might be possible if a druid coordinator gets and drops leadership repeatedly in quick succession.
    */
-  private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
-  /** {@link #poll()} and {@link #isStarted()} use readLock. */
-  private final Lock readLock = readWriteLock.readLock();
-  /** {@link #start()} and {@link #stop()} use writeLock. */
-  private final Lock writeLock = readWriteLock.writeLock();
+  private final ReentrantReadWriteLock startStopLock = new ReentrantReadWriteLock();
+
+  /**
+   * Used to ensure that {@link #poll()} is never run concurrently. It should already be so (at least in production
+   * code), where {@link #poll()} is called only from the task created in {@link #createPollTaskForStartOrder} and is
+   * scheduled in a single-threaded {@link #exec}, so this lock is an additional safety net in case there are bugs in
+   * the code, and for tests, where {@link #poll()} is called from the outside code.
+   *
+   * Not using {@link #startStopLock}.writeLock() in order to still be able to run {@link #poll()} concurrently with
+   * {@link #isStarted()}.
+   */
+  private final Object pollLock = new Object();
 
   private final ObjectMapper jsonMapper;
   private final Supplier<MetadataSegmentManagerConfig> config;
   private final Supplier<MetadataStorageTablesConfig> dbTables;
-  private final AtomicReference<ConcurrentHashMap<String, DruidDataSource>> dataSourcesRef;
   private final SQLMetadataConnector connector;
 
+  private ConcurrentHashMap<String, DruidDataSource> dataSources = new ConcurrentHashMap<>();
+
   /** The number of times this SQLMetadataSegmentManager was started. */
   private long startCount = 0;
   /**
@@ -129,7 +135,6 @@ public SQLMetadataSegmentManager(
     this.jsonMapper = jsonMapper;
     this.config = config;
     this.dbTables = dbTables;
-    this.dataSourcesRef = new AtomicReference<>(new ConcurrentHashMap<>());
     this.connector = connector;
   }
 
@@ -137,7 +142,8 @@ public SQLMetadataSegmentManager(
   @LifecycleStart
   public void start()
   {
-    writeLock.lock();
+    ReentrantReadWriteLock.WriteLock lock = startStopLock.writeLock();
+    lock.lock();
     try {
       if (isStarted()) {
         return;
@@ -151,68 +157,63 @@ public void start()
 
       final Duration delay = config.get().getPollDuration().toStandardDuration();
       exec.scheduleWithFixedDelay(
-          new Runnable()
-          {
-            @Override
-            public void run()
-            {
-              // poll() is synchronized together with start(), stop() and isStarted() to ensure that when stop() exists,
-              // poll() won't actually run anymore after that (it could only enter the syncrhonized section and exit
-              // immediately because the localStartedOrder doesn't match the new currentStartOrder). It's needed
-              // to avoid flakiness in SQLMetadataSegmentManagerTest.
-              // See https://github.com/apache/incubator-druid/issues/6028
-              readLock.lock();
-              try {
-                if (localStartOrder == currentStartOrder) {
-                  poll();
-                }
-              }
-              catch (Exception e) {
-                log.makeAlert(e, "uncaught exception in segment manager polling thread").emit();
-
-              }
-              finally {
-                readLock.unlock();
-              }
-            }
-          },
+          createPollTaskForStartOrder(localStartOrder),
           0,
           delay.getMillis(),
           TimeUnit.MILLISECONDS
       );
     }
     finally {
-      writeLock.unlock();
+      lock.unlock();
     }
   }
 
+  private Runnable createPollTaskForStartOrder(long startOrder)
+  {
+    return () -> {
+      // poll() is synchronized together with start(), stop() and isStarted() to ensure that when stop() exits, poll()
+      // won't actually run anymore after that (it could only enter the syncrhonized section and exit immediately
+      // because the localStartedOrder doesn't match the new currentStartOrder). It's needed to avoid flakiness in
+      // SQLMetadataSegmentManagerTest. See https://github.com/apache/incubator-druid/issues/6028
+      ReentrantReadWriteLock.ReadLock lock = startStopLock.readLock();
+      lock.lock();
+      try {
+        if (startOrder == currentStartOrder) {
+          poll();
+        }
+      }
+      catch (Exception e) {
+        log.makeAlert(e, "uncaught exception in segment manager polling thread").emit();
+      }
+      finally {
+        lock.unlock();
+      }
+    };
+  }
+
   @Override
   @LifecycleStop
   public void stop()
   {
-    writeLock.lock();
+    ReentrantReadWriteLock.WriteLock lock = startStopLock.writeLock();
+    lock.lock();
     try {
       if (!isStarted()) {
         return;
       }
 
-      final ConcurrentHashMap<String, DruidDataSource> emptyMap = new ConcurrentHashMap<>();
-      ConcurrentHashMap<String, DruidDataSource> current;
-      do {
-        current = dataSourcesRef.get();
-      } while (!dataSourcesRef.compareAndSet(current, emptyMap));
-
+      dataSources = new ConcurrentHashMap<>();
       currentStartOrder = -1;
       exec.shutdownNow();
       exec = null;
     }
     finally {
-      writeLock.unlock();
+      lock.unlock();
     }
   }
 
   @Override
-  public boolean enableDatasource(final String ds)
+  public boolean enableDataSource(final String dataSource)
   {
     try {
       final IDBI dbi = connector.getDBI();
@@ -227,7 +228,7 @@ public boolean enableDatasource(final String ds)
                           )
                       )
                       .setFetchSize(connector.getStreamingFetchSize())
-                      .bind("dataSource", ds)
+                      .bind("dataSource", dataSource)
                       .map(ByteArrayMapper.FIRST)
                       .iterator(),
                   payload -> {
@@ -271,7 +272,7 @@ public Void withHandle(Handle handle)
                     StringUtils.format(
                         "UPDATE %s SET used=true WHERE id = '%s'",
                         getSegmentsTable(),
-                        segment.getIdentifier()
+                        segment.getId()
                     )
                 );
               }
@@ -283,7 +284,7 @@ public Void withHandle(Handle handle)
       );
     }
     catch (Exception e) {
-      log.error(e, "Exception enabling datasource %s", ds);
+      log.error(e, "Exception enabling datasource %s", dataSource);
       return false;
     }
 
@@ -300,9 +301,7 @@ public boolean enableSegment(final String segmentId)
             @Override
             public Void withHandle(Handle handle)
             {
-              handle.createStatement(
-                  StringUtils.format("UPDATE %s SET used=true WHERE id = :id", getSegmentsTable())
-              )
+              handle.createStatement(StringUtils.format("UPDATE %s SET used=true WHERE id = :id", getSegmentsTable()))
                     .bind("id", segmentId)
                     .execute();
               return null;
@@ -319,23 +318,23 @@ public Void withHandle(Handle handle)
   }
 
   @Override
-  public boolean removeDatasource(final String ds)
+  public boolean removeDataSource(final String dataSource)
   {
     try {
       final int removed = connector.getDBI().withHandle(
           handle -> handle.createStatement(
               StringUtils.format("UPDATE %s SET used=false WHERE dataSource = :dataSource", getSegmentsTable())
-          ).bind("dataSource", ds).execute()
+          ).bind("dataSource", dataSource).execute()
       );
 
-      dataSourcesRef.get().remove(ds);
+      dataSources.remove(dataSource);
 
       if (removed == 0) {
         return false;
       }
     }
     catch (Exception e) {
-      log.error(e, "Error removing datasource %s", ds);
+      log.error(e, "Error removing datasource %s", dataSource);
       return false;
     }
 
@@ -343,36 +342,67 @@ public boolean removeDatasource(final String ds)
   }
 
   @Override
-  public boolean removeSegment(String ds, final String segmentID)
+  public boolean removeSegment(String dataSourceName, final String segmentId)
   {
     try {
-      final int removed = connector.getDBI().withHandle(
-          handle -> handle.createStatement(
-              StringUtils.format("UPDATE %s SET used=false WHERE id = :segmentID", getSegmentsTable())
-          ).bind("segmentID", segmentID).execute()
+      final boolean removed = removeSegmentFromTable(segmentId);
+
+      // Call iteratePossibleParsingsWithDataSource() outside of dataSources.computeIfPresent() because the former is a
+      // potentially expensive operation, while lambda to be passed into computeIfPresent() should preferably run fast.
+      List<SegmentId> possibleSegmentIds = SegmentId.iteratePossibleParsingsWithDataSource(dataSourceName, segmentId);
+      dataSources.computeIfPresent(
+          dataSourceName,
+          (dsName, dataSource) -> {
+            for (SegmentId possibleSegmentId : possibleSegmentIds) {
+              if (dataSource.removeSegment(possibleSegmentId) != null) {
+                break;
+              }
+            }
+            // Returning null from the lambda here makes the ConcurrentHashMap to remove the current entry.
+            //noinspection ReturnOfNull
+            return dataSource.isEmpty() ? null : dataSource;
+          }
       );
 
-      ConcurrentHashMap<String, DruidDataSource> dataSourceMap = dataSourcesRef.get();
-
-      DruidDataSource dataSource = dataSourceMap.get(ds);
-      if (dataSource != null) {
-        dataSource.removePartition(segmentID);
-
-        if (dataSource.isEmpty()) {
-          dataSourceMap.remove(ds);
-        }
-      }
+      return removed;
+    }
+    catch (Exception e) {
+      log.error(e, e.toString());
+      return false;
+    }
+  }
 
-      if (removed == 0) {
-        return false;
-      }
+  @Override
+  public boolean removeSegment(SegmentId segmentId)
+  {
+    try {
+      final boolean removed = removeSegmentFromTable(segmentId.toString());
+      dataSources.computeIfPresent(
+          segmentId.getDataSource(),
+          (dsName, dataSource) -> {
+            dataSource.removeSegment(segmentId);
+            // Returning null from the lambda here makes the ConcurrentHashMap to remove the current entry.
+            //noinspection ReturnOfNull
+            return dataSource.isEmpty() ? null : dataSource;
+          }
+      );
+      return removed;
     }
     catch (Exception e) {
       log.error(e, e.toString());
       return false;
     }
+  }
 
-    return true;
+  private boolean removeSegmentFromTable(String segmentId)
+  {
+    final int removed = connector.getDBI().withHandle(
+        handle -> handle
+            .createStatement(StringUtils.format("UPDATE %s SET used=false WHERE id = :segmentID", getSegmentsTable()))
+            .bind("segmentID", segmentId)
+            .execute()
+    );
+    return removed > 0;
   }
 
   @Override
@@ -380,35 +410,35 @@ public boolean isStarted()
   {
     // isStarted() is synchronized together with start(), stop() and poll() to ensure that the latest currentStartOrder
     // is always visible. readLock should be used to avoid unexpected performance degradation of DruidCoordinator.
-    readLock.lock();
+    ReentrantReadWriteLock.ReadLock lock = startStopLock.readLock();
+    lock.lock();
     try {
       return currentStartOrder >= 0;
     }
     finally {
-      readLock.unlock();
+      lock.unlock();
     }
   }
 
   @Override
   @Nullable
-  public ImmutableDruidDataSource getInventoryValue(String key)
+  public ImmutableDruidDataSource getDataSource(String dataSourceName)
   {
-    final DruidDataSource dataSource = dataSourcesRef.get().get(key);
+    final DruidDataSource dataSource = dataSources.get(dataSourceName);
     return dataSource == null ? null : dataSource.toImmutableDruidDataSource();
   }
 
   @Override
-  public Collection<ImmutableDruidDataSource> getInventory()
+  public Collection<ImmutableDruidDataSource> getDataSources()
   {
-    return dataSourcesRef.get()
-                         .values()
-                         .stream()
-                         .map(DruidDataSource::toImmutableDruidDataSource)
-                         .collect(Collectors.toList());
+    return dataSources.values()
+                      .stream()
+                      .map(DruidDataSource::toImmutableDruidDataSource)
+                      .collect(Collectors.toList());
   }
 
   @Override
-  public Collection<String> getAllDatasourceNames()
+  public Collection<String> getAllDataSourceNames()
   {
     return connector.getDBI().withHandle(
         handle -> handle.createQuery(
@@ -439,100 +469,78 @@ public List<String> fold(
   @Override
   public void poll()
   {
-    try {
-      ConcurrentHashMap<String, DruidDataSource> newDataSources = new ConcurrentHashMap<>();
-
-      log.debug("Starting polling of segment table");
+    synchronized (pollLock) {
+      try {
+        doPoll();
+      }
+      catch (Exception e) {
+        log.makeAlert(e, "Problem polling DB.").emit();
+      }
+    }
+  }
 
-      // some databases such as PostgreSQL require auto-commit turned off
-      // to stream results back, enabling transactions disables auto-commit
-      //
-      // setting connection to read-only will allow some database such as MySQL
-      // to automatically use read-only transaction mode, further optimizing the query
-      final List<DataSegment> segments = connector.inReadOnlyTransaction(
-          new TransactionCallback<List<DataSegment>>()
+  private void doPoll()
+  {
+    log.debug("Starting polling of segment table");
+
+    // some databases such as PostgreSQL require auto-commit turned off
+    // to stream results back, enabling transactions disables auto-commit
+    //
+    // setting connection to read-only will allow some database such as MySQL
+    // to automatically use read-only transaction mode, further optimizing the query
+    final List<DataSegment> segments = connector.inReadOnlyTransaction(
+        new TransactionCallback<List<DataSegment>>()
+        {
+          @Override
+          public List<DataSegment> inTransaction(Handle handle, TransactionStatus status)
           {
-            @Override
-            public List<DataSegment> inTransaction(Handle handle, TransactionStatus status)
-            {
-              return handle
-                  .createQuery(StringUtils.format("SELECT payload FROM %s WHERE used=true", getSegmentsTable()))
-                  .setFetchSize(connector.getStreamingFetchSize())
-                  .map(
-                      new ResultSetMapper<DataSegment>()
+            return handle
+                .createQuery(StringUtils.format("SELECT payload FROM %s WHERE used=true", getSegmentsTable()))
+                .setFetchSize(connector.getStreamingFetchSize())
+                .map(
+                    new ResultSetMapper<DataSegment>()
+                    {
+                      @Override
+                      public DataSegment map(int index, ResultSet r, StatementContext ctx) throws SQLException
                       {
-                        @Override
-                        public DataSegment map(int index, ResultSet r, StatementContext ctx)
-                            throws SQLException
-                        {
-                          try {
-                            return DATA_SEGMENT_INTERNER.intern(jsonMapper.readValue(
-                                r.getBytes("payload"),
-                                DataSegment.class
-                            ));
-                          }
-                          catch (IOException e) {
-                            log.makeAlert(e, "Failed to read segment from db.").emit();
-                            return null;
-                          }
+                        try {
+                          return DATA_SEGMENT_INTERNER.intern(jsonMapper.readValue(
+                              r.getBytes("payload"),
+                              DataSegment.class
+                          ));
+                        }
+                        catch (IOException e) {
+                          log.makeAlert(e, "Failed to read segment from db.").emit();
+                          return null;
                         }
                       }
-                  )
-                  .list();
-            }
+                    }
+                )
+                .list();
           }
-      );
+        }
+    );
 
-      if (segments == null || segments.isEmpty()) {
-        log.warn("No segments found in the database!");
-        return;
-      }
+    if (segments == null || segments.isEmpty()) {
+      log.warn("No segments found in the database!");
+      return;
+    }
 
-      final Collection<DataSegment> segmentsFinal = Collections2.filter(
-          segments, Predicates.notNull()
-      );
+    log.info("Polled and found %,d segments in the database", segments.size());
 
-      log.info("Polled and found %,d segments in the database", segments.size());
-
-      for (final DataSegment segment : segmentsFinal) {
-        String datasourceName = segment.getDataSource();
-
-        DruidDataSource dataSource = newDataSources.get(datasourceName);
-        if (dataSource == null) {
-          dataSource = new DruidDataSource(
-              datasourceName,
-              ImmutableMap.of("created", DateTimes.nowUtc().toString())
-          );
-
-          Object shouldBeNull = newDataSources.put(
-              datasourceName,
-              dataSource
-          );
-          if (shouldBeNull != null) {
-            log.warn(
-                "Just put key[%s] into dataSources and what was there wasn't null!?  It was[%s]",
-                datasourceName,
-                shouldBeNull
-            );
-          }
-        }
+    ConcurrentHashMap<String, DruidDataSource> newDataSources = new ConcurrentHashMap<>();
 
-        // For performance reasons, make sure we check for the existence of a segment using containsSegment(),
-        // which performs a key-based lookup, instead of calling contains() on the collection returned by
-        // dataSource.getSegments(). In Map values collections, the contains() method is a linear scan.
-        if (!dataSource.containsSegment(segment)) {
-          dataSource.addSegment(segment);
-        }
-      }
+    ImmutableMap<String, String> dataSourceProperties = ImmutableMap.of("created", DateTimes.nowUtc().toString());
+    segments
+        .stream()
+        .filter(Objects::nonNull)
+        .forEach(segment -> {
+          newDataSources
+              .computeIfAbsent(segment.getDataSource(), dsName -> new DruidDataSource(dsName, dataSourceProperties))
+              .addSegmentIfAbsent(segment);
+        });
 
-      ConcurrentHashMap<String, DruidDataSource> current;
-      do {
-        current = dataSourcesRef.get();
-      } while (!dataSourcesRef.compareAndSet(current, newDataSources));
-    }
-    catch (Exception e) {
-      log.makeAlert(e, "Problem polling DB.").emit();
-    }
+    dataSources = newDataSources;
   }
 
   private String getSegmentsTable()
diff --git a/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentPublisher.java b/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentPublisher.java
index f982cd36eb25..6c33396de69f 100644
--- a/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentPublisher.java
+++ b/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentPublisher.java
@@ -65,7 +65,7 @@ public SQLMetadataSegmentPublisher(
   public void publishSegment(final DataSegment segment) throws IOException
   {
     publishSegment(
-        segment.getIdentifier(),
+        segment.getId().toString(),
         segment.getDataSource(),
         DateTimes.nowUtc().toString(),
         segment.getInterval().getStart().toString(),
@@ -79,7 +79,7 @@ public void publishSegment(final DataSegment segment) throws IOException
 
   @VisibleForTesting
   void publishSegment(
-      final String identifier,
+      final String segmentId,
       final String dataSource,
       final String createdDate,
       final String start,
@@ -101,14 +101,14 @@ public List<Map<String, Object>> withHandle(Handle handle)
               return handle.createQuery(
                   StringUtils.format("SELECT id FROM %s WHERE id=:id", config.getSegmentsTable())
               )
-                           .bind("id", identifier)
+                           .bind("id", segmentId)
                            .list();
             }
           }
       );
 
       if (!exists.isEmpty()) {
-        log.info("Found [%s] in DB, not updating DB", identifier);
+        log.info("Found [%s] in DB, not updating DB", segmentId);
         return;
       }
 
@@ -119,7 +119,7 @@ public List<Map<String, Object>> withHandle(Handle handle)
             public Void withHandle(Handle handle)
             {
               handle.createStatement(statement)
-                    .bind("id", identifier)
+                    .bind("id", segmentId)
                     .bind("dataSource", dataSource)
                     .bind("created_date", createdDate)
                     .bind("start", start)
diff --git a/server/src/main/java/org/apache/druid/query/lookup/LookupReferencesManager.java b/server/src/main/java/org/apache/druid/query/lookup/LookupReferencesManager.java
index 05f802d1a2c6..f85bafcf19bb 100644
--- a/server/src/main/java/org/apache/druid/query/lookup/LookupReferencesManager.java
+++ b/server/src/main/java/org/apache/druid/query/lookup/LookupReferencesManager.java
@@ -562,8 +562,7 @@ private LookupUpdateState atomicallyUpdateStateRef(Function<LookupUpdateState, L
     }
   }
 
-  private FullResponseHolder fetchLookupsForTier(String tier)
-      throws InterruptedException, IOException
+  private FullResponseHolder fetchLookupsForTier(String tier) throws InterruptedException, IOException
   {
     return druidLeaderClient.go(
         druidLeaderClient.makeRequest(
diff --git a/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentFinder.java b/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentFinder.java
index cec200342c57..6e5cca0df479 100644
--- a/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentFinder.java
+++ b/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentFinder.java
@@ -26,6 +26,7 @@
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.commons.io.FileUtils;
+import org.apache.druid.timeline.SegmentId;
 
 import java.io.File;
 import java.io.IOException;
@@ -51,7 +52,7 @@ public LocalDataSegmentFinder(ObjectMapper mapper)
   @Override
   public Set<DataSegment> findSegments(String workingDirPath, boolean updateDescriptor) throws SegmentLoadingException
   {
-    final Map<String, Pair<DataSegment, Long>> timestampedSegments = new HashMap<>();
+    final Map<SegmentId, Pair<DataSegment, Long>> timestampedSegments = new HashMap<>();
 
     final File workingDir = new File(workingDirPath);
     if (!workingDir.isDirectory()) {
@@ -63,7 +64,9 @@ public Set<DataSegment> findSegments(String workingDirPath, boolean updateDescri
   }
 
   private void recursiveSearchSegments(
-      Map<String, Pair<DataSegment, Long>> timestampedSegments, File workingDir, boolean updateDescriptor
+      Map<SegmentId, Pair<DataSegment, Long>> timestampedSegments,
+      File workingDir,
+      boolean updateDescriptor
   ) throws SegmentLoadingException
   {
     for (File file : workingDir.listFiles()) {
@@ -74,7 +77,7 @@ private void recursiveSearchSegments(
         if (indexZip.exists()) {
           try {
             final DataSegment dataSegment = mapper.readValue(FileUtils.readFileToString(file), DataSegment.class);
-            log.info("Found segment [%s] located at [%s]", dataSegment.getIdentifier(), indexZip.getAbsoluteFile());
+            log.info("Found segment [%s] located at [%s]", dataSegment.getId(), indexZip.getAbsoluteFile());
             final Map<String, Object> loadSpec = dataSegment.getLoadSpec();
             if (!loadSpec.get("type").equals(LocalDataStorageDruidModule.SCHEME) || !loadSpec.get("path")
                                                                                              .equals(indexZip.getAbsoluteFile())) {
diff --git a/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentKiller.java b/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentKiller.java
index 77d02e0a7ef8..baca70ef0a11 100644
--- a/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentKiller.java
+++ b/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentKiller.java
@@ -48,7 +48,7 @@ public LocalDataSegmentKiller(LocalDataSegmentPusherConfig config)
   public void kill(DataSegment segment) throws SegmentLoadingException
   {
     final File path = getPath(segment);
-    log.info("killing segment[%s] mapped to path[%s]", segment.getIdentifier(), path);
+    log.info("killing segment[%s] mapped to path[%s]", segment.getId(), path);
 
     try {
       if (path.getName().endsWith(".zip")) {
diff --git a/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentPusher.java b/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentPusher.java
index b81baa2e4c73..38f67319b3ef 100644
--- a/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentPusher.java
+++ b/server/src/main/java/org/apache/druid/segment/loading/LocalDataSegmentPusher.java
@@ -76,7 +76,7 @@ public DataSegment push(final File dataSegmentFile, final DataSegment segment, f
     final File baseStorageDir = config.getStorageDirectory();
     final File outDir = new File(baseStorageDir, this.getStorageDir(segment, useUniquePath));
 
-    log.info("Copying segment[%s] to local filesystem at location[%s]", segment.getIdentifier(), outDir.toString());
+    log.info("Copying segment[%s] to local filesystem at location[%s]", segment.getId(), outDir.toString());
 
     if (dataSegmentFile.equals(outDir)) {
       long size = 0;
@@ -93,7 +93,7 @@ public DataSegment push(final File dataSegmentFile, final DataSegment segment, f
     }
 
     final File tmpOutDir = new File(baseStorageDir, makeIntermediateDir());
-    log.info("Creating intermediate directory[%s] for segment[%s]", tmpOutDir.toString(), segment.getIdentifier());
+    log.info("Creating intermediate directory[%s] for segment[%s]", tmpOutDir.toString(), segment.getId());
     FileUtils.forceMkdir(tmpOutDir);
 
     try {
diff --git a/server/src/main/java/org/apache/druid/segment/loading/SegmentLoaderLocalCacheManager.java b/server/src/main/java/org/apache/druid/segment/loading/SegmentLoaderLocalCacheManager.java
index eebf631e7c89..e1e41496cfb2 100644
--- a/server/src/main/java/org/apache/druid/segment/loading/SegmentLoaderLocalCacheManager.java
+++ b/server/src/main/java/org/apache/druid/segment/loading/SegmentLoaderLocalCacheManager.java
@@ -164,7 +164,7 @@ private StorageLocation loadSegmentWithRetry(DataSegment segment, String storage
         }
       }
     }
-    throw new SegmentLoadingException("Failed to load segment %s in all locations.", segment.getIdentifier());
+    throw new SegmentLoadingException("Failed to load segment %s in all locations.", segment.getId());
   }
 
   private void loadInLocationWithStartMarker(DataSegment segment, File storageDir) throws SegmentLoadingException
@@ -201,7 +201,7 @@ private void loadInLocation(DataSegment segment, File storageDir) throws Segment
     if (result.getSize() != segment.getSize()) {
       log.warn(
           "Segment [%s] is different than expected size. Expected [%d] found [%d]",
-          segment.getIdentifier(),
+          segment.getId(),
           segment.getSize(),
           result.getSize()
       );
diff --git a/server/src/main/java/org/apache/druid/segment/loading/StorageLocation.java b/server/src/main/java/org/apache/druid/segment/loading/StorageLocation.java
index 6c603e3414d5..24fe18f03dc7 100644
--- a/server/src/main/java/org/apache/druid/segment/loading/StorageLocation.java
+++ b/server/src/main/java/org/apache/druid/segment/loading/StorageLocation.java
@@ -90,7 +90,7 @@ boolean canHandle(DataSegment segment)
     if (available() < segment.getSize()) {
       log.warn(
           "Segment[%s:%,d] too large for storage[%s:%,d]. Check your druid.segmentCache.locations maxSize param",
-          segment.getIdentifier(), segment.getSize(), getPath(), available()
+          segment.getId(), segment.getSize(), getPath(), available()
       );
       return false;
     }
@@ -100,7 +100,7 @@ boolean canHandle(DataSegment segment)
       if ((freeSpaceToKeep + segment.getSize()) > currFreeSpace) {
         log.warn(
             "Segment[%s:%,d] too large for storage[%s:%,d] to maintain suggested freeSpace[%d], current freeSpace is [%d].",
-            segment.getIdentifier(),
+            segment.getId(),
             segment.getSize(),
             getPath(),
             available(),
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/FireHydrant.java b/server/src/main/java/org/apache/druid/segment/realtime/FireHydrant.java
index dfa47096c0b2..9be6d80ec362 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/FireHydrant.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/FireHydrant.java
@@ -25,6 +25,7 @@
 import org.apache.druid.segment.ReferenceCountingSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.incremental.IncrementalIndex;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 import javax.annotation.Nullable;
@@ -39,12 +40,10 @@ public class FireHydrant
   private final AtomicReference<ReferenceCountingSegment> adapter;
   private volatile IncrementalIndex index;
 
-  public FireHydrant(IncrementalIndex index, int count, String segmentIdentifier)
+  public FireHydrant(IncrementalIndex index, int count, SegmentId segmentId)
   {
     this.index = index;
-    this.adapter = new AtomicReference<>(
-        new ReferenceCountingSegment(new IncrementalIndexSegment(index, segmentIdentifier))
-    );
+    this.adapter = new AtomicReference<>(new ReferenceCountingSegment(new IncrementalIndexSegment(index, segmentId)));
     this.count = count;
   }
 
@@ -60,9 +59,9 @@ public IncrementalIndex getIndex()
     return index;
   }
 
-  public String getSegmentIdentifier()
+  public SegmentId getSegmentId()
   {
-    return adapter.get().getIdentifier();
+    return adapter.get().getId();
   }
 
   public Interval getSegmentDataInterval()
@@ -109,12 +108,12 @@ public void swapSegment(@Nullable Segment newSegment)
         return;
       }
       if (currentSegment != null && newSegment != null &&
-          !newSegment.getIdentifier().equals(currentSegment.getIdentifier())) {
+          !newSegment.getId().equals(currentSegment.getId())) {
         // Sanity check: identifier should not change
         throw new ISE(
             "WTF?! Cannot swap identifier[%s] -> [%s]!",
-            currentSegment.getIdentifier(),
-            newSegment.getIdentifier()
+            currentSegment.getId(),
+            newSegment.getId()
         );
       }
       if (currentSegment == newSegment) {
@@ -144,7 +143,7 @@ public String toString()
     // Do not include IncrementalIndex in toString as AbstractIndex.toString() actually prints
     // all the rows in the index
     return "FireHydrant{" +
-           ", queryable=" + adapter.get().getIdentifier() +
+           ", queryable=" + adapter.get().getId() +
            ", count=" + count +
            '}';
   }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java
index 3026eb4ded9c..7f07ea74030b 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Appenderator.java
@@ -56,9 +56,9 @@ public interface Appenderator extends QuerySegmentWalker, Closeable
   Object startJob();
 
   /**
-   * Same as {@link #add(SegmentIdentifier, InputRow, Supplier, boolean)}, with allowIncrementalPersists set to true
+   * Same as {@link #add(SegmentIdWithShardSpec, InputRow, Supplier, boolean)}, with allowIncrementalPersists set to true
    */
-  default AppenderatorAddResult add(SegmentIdentifier identifier, InputRow row, Supplier<Committer> committerSupplier)
+  default AppenderatorAddResult add(SegmentIdWithShardSpec identifier, InputRow row, Supplier<Committer> committerSupplier)
       throws IndexSizeExceededException, SegmentNotWritableException
   {
     return add(identifier, row, committerSupplier, true);
@@ -95,7 +95,7 @@ default AppenderatorAddResult add(SegmentIdentifier identifier, InputRow row, Su
    * @throws SegmentNotWritableException if the requested segment is known, but has been closed
    */
   AppenderatorAddResult add(
-      SegmentIdentifier identifier,
+      SegmentIdWithShardSpec identifier,
       InputRow row,
       @Nullable Supplier<Committer> committerSupplier,
       boolean allowIncrementalPersists
@@ -105,7 +105,7 @@ AppenderatorAddResult add(
   /**
    * Returns a list of all currently active segments.
    */
-  List<SegmentIdentifier> getSegments();
+  List<SegmentIdWithShardSpec> getSegments();
 
   /**
    * Returns the number of rows in a particular pending segment.
@@ -116,7 +116,7 @@ AppenderatorAddResult add(
    *
    * @throws IllegalStateException if the segment is unknown
    */
-  int getRowCount(SegmentIdentifier identifier);
+  int getRowCount(SegmentIdWithShardSpec identifier);
 
   /**
    * Returns the number of total rows in this appenderator of all segments pending push.
@@ -147,7 +147,7 @@ AppenderatorAddResult add(
    *
    * @return future that resolves when data is dropped
    */
-  ListenableFuture<?> drop(SegmentIdentifier identifier);
+  ListenableFuture<?> drop(SegmentIdWithShardSpec identifier);
 
   /**
    * Persist any in-memory indexed data to durable storage. This may be only somewhat durable, e.g. the
@@ -183,7 +183,7 @@ AppenderatorAddResult add(
    * that have been pushed and the commit metadata from the Committer.
    */
   ListenableFuture<SegmentsAndMetadata> push(
-      Collection<SegmentIdentifier> identifiers,
+      Collection<SegmentIdWithShardSpec> identifiers,
       @Nullable Committer committer,
       boolean useUniquePath
   );
@@ -205,14 +205,14 @@ ListenableFuture<SegmentsAndMetadata> push(
   void closeNow();
 
   /**
-   * Result of {@link Appenderator#add(SegmentIdentifier, InputRow, Supplier, boolean)} containing following information
-   * - SegmentIdentifier - identifier of segment to which rows are being added
+   * Result of {@link Appenderator#add} containing following information
+   * - {@link SegmentIdWithShardSpec} - identifier of segment to which rows are being added
    * - int - positive number indicating how many summarized rows exist in this segment so far and
    * - boolean - true if {@param allowIncrementalPersists} is set to false and persist is required; false otherwise
    */
   class AppenderatorAddResult
   {
-    private final SegmentIdentifier segmentIdentifier;
+    private final SegmentIdWithShardSpec segmentIdentifier;
     private final int numRowsInSegment;
     private final boolean isPersistRequired;
 
@@ -220,7 +220,7 @@ class AppenderatorAddResult
     private final ParseException parseException;
 
     AppenderatorAddResult(
-        SegmentIdentifier identifier,
+        SegmentIdWithShardSpec identifier,
         int numRowsInSegment,
         boolean isPersistRequired,
         @Nullable ParseException parseException
@@ -232,7 +232,7 @@ class AppenderatorAddResult
       this.parseException = parseException;
     }
 
-    SegmentIdentifier getSegmentIdentifier()
+    SegmentIdWithShardSpec getSegmentIdentifier()
     {
       return segmentIdentifier;
     }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorDriverAddResult.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorDriverAddResult.java
index e80658ee2cc1..4be00af88f15 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorDriverAddResult.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorDriverAddResult.java
@@ -30,7 +30,7 @@
  */
 public class AppenderatorDriverAddResult
 {
-  private final SegmentIdentifier segmentIdentifier;
+  private final SegmentIdWithShardSpec segmentIdentifier;
   private final int numRowsInSegment;
   private final long totalNumRowsInAppenderator;
   private final boolean isPersistRequired;
@@ -39,7 +39,7 @@ public class AppenderatorDriverAddResult
   private final ParseException parseException;
 
   public static AppenderatorDriverAddResult ok(
-      SegmentIdentifier segmentIdentifier,
+      SegmentIdWithShardSpec segmentIdentifier,
       int numRowsInSegment,
       long totalNumRowsInAppenderator,
       boolean isPersistRequired,
@@ -61,7 +61,7 @@ public static AppenderatorDriverAddResult fail()
   }
 
   private AppenderatorDriverAddResult(
-      @Nullable SegmentIdentifier segmentIdentifier,
+      @Nullable SegmentIdWithShardSpec segmentIdentifier,
       int numRowsInSegment,
       long totalNumRowsInAppenderator,
       boolean isPersistRequired,
@@ -80,7 +80,7 @@ public boolean isOk()
     return segmentIdentifier != null;
   }
 
-  public SegmentIdentifier getSegmentIdentifier()
+  public SegmentIdWithShardSpec getSegmentIdentifier()
   {
     return segmentIdentifier;
   }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorDriverMetadata.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorDriverMetadata.java
index 03cd0ff45b65..1e8b289442ec 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorDriverMetadata.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorDriverMetadata.java
@@ -44,8 +44,8 @@ public AppenderatorDriverMetadata(
       @JsonProperty("lastSegmentIds") Map<String, String> lastSegmentIds,
       @JsonProperty("callerMetadata") Object callerMetadata,
       // Next two properties are for backwards compatibility, should be removed on versions greater than 0.12.x
-      @JsonProperty("activeSegments") Map<String, List<SegmentIdentifier>> activeSegments,
-      @JsonProperty("publishPendingSegments") Map<String, List<SegmentIdentifier>> publishPendingSegments
+      @JsonProperty("activeSegments") Map<String, List<SegmentIdWithShardSpec>> activeSegments,
+      @JsonProperty("publishPendingSegments") Map<String, List<SegmentIdWithShardSpec>> publishPendingSegments
   )
   {
     Preconditions.checkState(
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorImpl.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorImpl.java
index 808c8ff1dfbc..8ce16d035150 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorImpl.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorImpl.java
@@ -121,8 +121,8 @@ public class AppenderatorImpl implements Appenderator
   private final IndexIO indexIO;
   private final IndexMerger indexMerger;
   private final Cache cache;
-  private final Map<SegmentIdentifier, Sink> sinks = new ConcurrentHashMap<>();
-  private final Set<SegmentIdentifier> droppingSinks = Sets.newConcurrentHashSet();
+  private final Map<SegmentIdWithShardSpec, Sink> sinks = new ConcurrentHashMap<>();
+  private final Set<SegmentIdWithShardSpec> droppingSinks = Sets.newConcurrentHashSet();
   private final VersionedIntervalTimeline<String, Sink> sinkTimeline = new VersionedIntervalTimeline<>(
       String.CASE_INSENSITIVE_ORDER
   );
@@ -218,7 +218,7 @@ private void throwPersistErrorIfExists()
 
   @Override
   public AppenderatorAddResult add(
-      final SegmentIdentifier identifier,
+      final SegmentIdWithShardSpec identifier,
       final InputRow row,
       @Nullable final Supplier<Committer> committerSupplier,
       final boolean allowIncrementalPersists
@@ -325,13 +325,13 @@ public void onFailure(Throwable t)
   }
 
   @Override
-  public List<SegmentIdentifier> getSegments()
+  public List<SegmentIdWithShardSpec> getSegments()
   {
     return ImmutableList.copyOf(sinks.keySet());
   }
 
   @Override
-  public int getRowCount(final SegmentIdentifier identifier)
+  public int getRowCount(final SegmentIdWithShardSpec identifier)
   {
     final Sink sink = sinks.get(identifier);
 
@@ -361,7 +361,7 @@ long getBytesCurrentlyInMemory()
   }
 
   @VisibleForTesting
-  long getBytesInMemory(SegmentIdentifier identifier)
+  long getBytesInMemory(SegmentIdWithShardSpec identifier)
   {
     final Sink sink = sinks.get(identifier);
 
@@ -372,7 +372,7 @@ long getBytesInMemory(SegmentIdentifier identifier)
     }
   }
 
-  private Sink getOrCreateSink(final SegmentIdentifier identifier)
+  private Sink getOrCreateSink(final SegmentIdWithShardSpec identifier)
   {
     Sink retVal = sinks.get(identifier);
 
@@ -452,7 +452,7 @@ public void clear() throws InterruptedException
 
         // Drop everything.
         final List<ListenableFuture<?>> futures = Lists.newArrayList();
-        for (Map.Entry<SegmentIdentifier, Sink> entry : sinks.entrySet()) {
+        for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
           futures.add(abandonSegment(entry.getKey(), entry.getValue(), true));
         }
 
@@ -466,7 +466,7 @@ public void clear() throws InterruptedException
   }
 
   @Override
-  public ListenableFuture<?> drop(final SegmentIdentifier identifier)
+  public ListenableFuture<?> drop(final SegmentIdWithShardSpec identifier)
   {
     final Sink sink = sinks.get(identifier);
     if (sink != null) {
@@ -482,16 +482,16 @@ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
     throwPersistErrorIfExists();
 
     final Map<String, Integer> currentHydrants = Maps.newHashMap();
-    final List<Pair<FireHydrant, SegmentIdentifier>> indexesToPersist = Lists.newArrayList();
+    final List<Pair<FireHydrant, SegmentIdWithShardSpec>> indexesToPersist = Lists.newArrayList();
     int numPersistedRows = 0;
     long bytesPersisted = 0L;
-    for (SegmentIdentifier identifier : sinks.keySet()) {
+    for (SegmentIdWithShardSpec identifier : sinks.keySet()) {
       final Sink sink = sinks.get(identifier);
       if (sink == null) {
         throw new ISE("No sink for identifier: %s", identifier);
       }
       final List<FireHydrant> hydrants = Lists.newArrayList(sink);
-      currentHydrants.put(identifier.getIdentifierAsString(), hydrants.size());
+      currentHydrants.put(identifier.toString(), hydrants.size());
       numPersistedRows += sink.getNumRowsInMemory();
       bytesPersisted += sink.getBytesInMemory();
 
@@ -522,7 +522,7 @@ public ListenableFuture<Object> persistAll(@Nullable final Committer committer)
           public Object doCall() throws IOException
           {
             try {
-              for (Pair<FireHydrant, SegmentIdentifier> pair : indexesToPersist) {
+              for (Pair<FireHydrant, SegmentIdWithShardSpec> pair : indexesToPersist) {
                 metrics.incrementRowOutputCount(persistHydrant(pair.lhs, pair.rhs));
               }
 
@@ -590,13 +590,13 @@ public Object doCall() throws IOException
 
   @Override
   public ListenableFuture<SegmentsAndMetadata> push(
-      final Collection<SegmentIdentifier> identifiers,
+      final Collection<SegmentIdWithShardSpec> identifiers,
       @Nullable final Committer committer,
       final boolean useUniquePath
   )
   {
-    final Map<SegmentIdentifier, Sink> theSinks = Maps.newHashMap();
-    for (final SegmentIdentifier identifier : identifiers) {
+    final Map<SegmentIdWithShardSpec, Sink> theSinks = Maps.newHashMap();
+    for (final SegmentIdWithShardSpec identifier : identifiers) {
       final Sink sink = sinks.get(identifier);
       if (sink == null) {
         throw new ISE("No sink for identifier: %s", identifier);
@@ -614,7 +614,7 @@ public ListenableFuture<SegmentsAndMetadata> push(
         (Function<Object, SegmentsAndMetadata>) commitMetadata -> {
           final List<DataSegment> dataSegments = Lists.newArrayList();
 
-          for (Map.Entry<SegmentIdentifier, Sink> entry : theSinks.entrySet()) {
+          for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : theSinks.entrySet()) {
             if (droppingSinks.contains(entry.getKey())) {
               log.info("Skipping push of currently-dropping sink[%s]", entry.getKey());
               continue;
@@ -656,7 +656,7 @@ private ListenableFuture<?> pushBarrier()
    *
    * @return segment descriptor, or null if the sink is no longer valid
    */
-  private DataSegment mergeAndPush(final SegmentIdentifier identifier, final Sink sink, final boolean useUniquePath)
+  private DataSegment mergeAndPush(final SegmentIdWithShardSpec identifier, final Sink sink, final boolean useUniquePath)
   {
     // Bail out if this sink is null or otherwise not what we expect.
     if (sinks.get(identifier) != sink) {
@@ -770,7 +770,7 @@ public void close()
     log.info("Shutting down...");
 
     final List<ListenableFuture<?>> futures = Lists.newArrayList();
-    for (Map.Entry<SegmentIdentifier, Sink> entry : sinks.entrySet()) {
+    for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
       futures.add(abandonSegment(entry.getKey(), entry.getValue(), false));
     }
 
@@ -829,13 +829,13 @@ public void closeNow()
     }
 
     log.info("Shutting down immediately...");
-    for (Map.Entry<SegmentIdentifier, Sink> entry : sinks.entrySet()) {
+    for (Map.Entry<SegmentIdWithShardSpec, Sink> entry : sinks.entrySet()) {
       try {
         segmentAnnouncer.unannounceSegment(entry.getValue().getSegment());
       }
       catch (Exception e) {
         log.makeAlert(e, "Failed to unannounce segment[%s]", schema.getDataSource())
-           .addData("identifier", entry.getKey().getIdentifierAsString())
+           .addData("identifier", entry.getKey().toString())
            .emit();
       }
     }
@@ -992,12 +992,12 @@ private Object bootstrapSinksFromDisk()
       }
 
       try {
-        final SegmentIdentifier identifier = objectMapper.readValue(
+        final SegmentIdWithShardSpec identifier = objectMapper.readValue(
             new File(sinkDir, "identifier.json"),
-            SegmentIdentifier.class
+            SegmentIdWithShardSpec.class
         );
 
-        final int committedHydrants = committed.getCommittedHydrants(identifier.getIdentifierAsString());
+        final int committedHydrants = committed.getCommittedHydrants(identifier.toString());
 
         if (committedHydrants <= 0) {
           log.info("Removing uncommitted sink at [%s]", sinkDir);
@@ -1030,10 +1030,7 @@ private Object bootstrapSinksFromDisk()
 
             hydrants.add(
                 new FireHydrant(
-                    new QueryableIndexSegment(
-                        identifier.getIdentifierAsString(),
-                        indexIO.loadIndex(hydrantDir)
-                    ),
+                    new QueryableIndexSegment(indexIO.loadIndex(hydrantDir), identifier.asSegmentId()),
                     hydrantNumber
                 )
             );
@@ -1075,10 +1072,7 @@ private Object bootstrapSinksFromDisk()
 
     // Make sure we loaded all committed sinks.
     final Set<String> loadedSinks = Sets.newHashSet(
-        Iterables.transform(
-            sinks.keySet(),
-            input -> input.getIdentifierAsString()
-        )
+        Iterables.transform(sinks.keySet(), SegmentIdWithShardSpec::toString)
     );
     final Set<String> missingSinks = Sets.difference(committed.getHydrants().keySet(), loadedSinks);
     if (!missingSinks.isEmpty()) {
@@ -1090,7 +1084,7 @@ private Object bootstrapSinksFromDisk()
   }
 
   private ListenableFuture<?> abandonSegment(
-      final SegmentIdentifier identifier,
+      final SegmentIdWithShardSpec identifier,
       final Sink sink,
       final boolean removeOnDiskData
   )
@@ -1129,12 +1123,12 @@ public Object apply(@Nullable Object input)
                 commitLock.lock();
                 final Committed oldCommit = readCommit();
                 if (oldCommit != null) {
-                  writeCommit(oldCommit.without(identifier.getIdentifierAsString()));
+                  writeCommit(oldCommit.without(identifier.toString()));
                 }
               }
               catch (Exception e) {
                 log.makeAlert(e, "Failed to update committed segments[%s]", schema.getDataSource())
-                   .addData("identifier", identifier.getIdentifierAsString())
+                   .addData("identifier", identifier.toString())
                    .emit();
                 throw Throwables.propagate(e);
               }
@@ -1149,7 +1143,7 @@ public Object apply(@Nullable Object input)
             }
             catch (Exception e) {
               log.makeAlert(e, "Failed to unannounce segment[%s]", schema.getDataSource())
-                 .addData("identifier", identifier.getIdentifierAsString())
+                 .addData("identifier", identifier.toString())
                  .emit();
             }
 
@@ -1209,22 +1203,22 @@ private File computeLockFile()
     return new File(tuningConfig.getBasePersistDirectory(), ".lock");
   }
 
-  private File computePersistDir(SegmentIdentifier identifier)
+  private File computePersistDir(SegmentIdWithShardSpec identifier)
   {
-    return new File(tuningConfig.getBasePersistDirectory(), identifier.getIdentifierAsString());
+    return new File(tuningConfig.getBasePersistDirectory(), identifier.toString());
   }
 
-  private File computeIdentifierFile(SegmentIdentifier identifier)
+  private File computeIdentifierFile(SegmentIdWithShardSpec identifier)
   {
     return new File(computePersistDir(identifier), IDENTIFIER_FILE_NAME);
   }
 
-  private File computeDescriptorFile(SegmentIdentifier identifier)
+  private File computeDescriptorFile(SegmentIdWithShardSpec identifier)
   {
     return new File(computePersistDir(identifier), "descriptor.json");
   }
 
-  private File createPersistDirIfNeeded(SegmentIdentifier identifier) throws IOException
+  private File createPersistDirIfNeeded(SegmentIdWithShardSpec identifier) throws IOException
   {
     final File persistDir = computePersistDir(identifier);
     FileUtils.forceMkdir(persistDir);
@@ -1243,7 +1237,7 @@ private File createPersistDirIfNeeded(SegmentIdentifier identifier) throws IOExc
    *
    * @return the number of rows persisted
    */
-  private int persistHydrant(FireHydrant indexToPersist, SegmentIdentifier identifier)
+  private int persistHydrant(FireHydrant indexToPersist, SegmentIdWithShardSpec identifier)
   {
     synchronized (indexToPersist) {
       if (indexToPersist.hasSwapped()) {
@@ -1271,16 +1265,13 @@ private int persistHydrant(FireHydrant indexToPersist, SegmentIdentifier identif
         );
 
         indexToPersist.swapSegment(
-            new QueryableIndexSegment(
-                indexToPersist.getSegmentIdentifier(),
-                indexIO.loadIndex(persistedFile)
-            )
+            new QueryableIndexSegment(indexIO.loadIndex(persistedFile), indexToPersist.getSegmentId())
         );
         return numRows;
       }
       catch (IOException e) {
         log.makeAlert("dataSource[%s] -- incremental persist failed", schema.getDataSource())
-           .addData("segment", identifier.getIdentifierAsString())
+           .addData("segment", identifier.toString())
            .addData("count", indexToPersist.getCount())
            .emit();
 
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorPlumber.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorPlumber.java
index d0e72e3d6d1f..e60328996d0b 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorPlumber.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/AppenderatorPlumber.java
@@ -81,7 +81,7 @@ public class AppenderatorPlumber implements Plumber
   private final SegmentPublisher segmentPublisher;
   private final SegmentHandoffNotifier handoffNotifier;
   private final Object handoffCondition = new Object();
-  private final Map<Long, SegmentIdentifier> segments = new ConcurrentHashMap<>();
+  private final Map<Long, SegmentIdWithShardSpec> segments = new ConcurrentHashMap<>();
   private final Appenderator appenderator;
 
   private volatile boolean shuttingDown = false;
@@ -113,7 +113,7 @@ public AppenderatorPlumber(
     log.info("Creating plumber using rejectionPolicy[%s]", getRejectionPolicy());
   }
 
-  public Map<Long, SegmentIdentifier> getSegmentsView()
+  public Map<Long, SegmentIdWithShardSpec> getSegmentsView()
   {
     return ImmutableMap.copyOf(segments);
   }
@@ -148,7 +148,7 @@ public Object startJob()
   @Override
   public IncrementalIndexAddResult add(InputRow row, Supplier<Committer> committerSupplier) throws IndexSizeExceededException
   {
-    final SegmentIdentifier identifier = getSegmentIdentifier(row.getTimestampFromEpoch());
+    final SegmentIdWithShardSpec identifier = getSegmentIdentifier(row.getTimestampFromEpoch());
     if (identifier == null) {
       return Plumber.THROWAWAY;
     }
@@ -198,7 +198,7 @@ public void finishJob()
 
     shuttingDown = true;
 
-    List<SegmentIdentifier> pending = appenderator.getSegments();
+    List<SegmentIdWithShardSpec> pending = appenderator.getSegments();
     if (pending.isEmpty()) {
       log.info("No segments to hand off.");
     } else {
@@ -234,7 +234,7 @@ public void finishJob()
     }
   }
 
-  private SegmentIdentifier getSegmentIdentifier(long timestamp)
+  private SegmentIdWithShardSpec getSegmentIdentifier(long timestamp)
   {
     if (!rejectionPolicy.accept(timestamp)) {
       return null;
@@ -246,7 +246,7 @@ private SegmentIdentifier getSegmentIdentifier(long timestamp)
     DateTime truncatedDateTime = segmentGranularity.bucketStart(DateTimes.utc(timestamp));
     final long truncatedTime = truncatedDateTime.getMillis();
 
-    SegmentIdentifier retVal = segments.get(truncatedTime);
+    SegmentIdWithShardSpec retVal = segments.get(truncatedTime);
 
     if (retVal == null) {
       final Interval interval = new Interval(
@@ -254,7 +254,7 @@ private SegmentIdentifier getSegmentIdentifier(long timestamp)
           segmentGranularity.increment(truncatedDateTime)
       );
 
-      retVal = new SegmentIdentifier(
+      retVal = new SegmentIdWithShardSpec(
           schema.getDataSource(),
           interval,
           versioningPolicy.getVersion(interval),
@@ -281,7 +281,7 @@ protected void shutdownExecutors()
     }
   }
 
-  private void addSegment(final SegmentIdentifier identifier)
+  private void addSegment(final SegmentIdWithShardSpec identifier)
   {
     segments.put(identifier.getInterval().getStartMillis(), identifier);
     try {
@@ -306,7 +306,7 @@ private void addSegment(final SegmentIdentifier identifier)
     }
   }
 
-  public void dropSegment(final SegmentIdentifier identifier)
+  public void dropSegment(final SegmentIdWithShardSpec identifier)
   {
     log.info("Dropping segment: %s", identifier);
     segments.remove(identifier.getInterval().getStartMillis());
@@ -395,8 +395,8 @@ private void mergeAndPush()
     );
     long minTimestamp = minTimestampAsDate.getMillis();
 
-    final List<SegmentIdentifier> appenderatorSegments = appenderator.getSegments();
-    final List<SegmentIdentifier> segmentsToPush = Lists.newArrayList();
+    final List<SegmentIdWithShardSpec> appenderatorSegments = appenderator.getSegments();
+    final List<SegmentIdWithShardSpec> segmentsToPush = Lists.newArrayList();
 
     if (shuttingDown) {
       log.info("Found [%,d] segments. Attempting to hand off all of them.", appenderatorSegments.size());
@@ -408,7 +408,7 @@ private void mergeAndPush()
           minTimestampAsDate
       );
 
-      for (SegmentIdentifier segment : appenderatorSegments) {
+      for (SegmentIdWithShardSpec segment : appenderatorSegments) {
         final Long intervalStart = segment.getInterval().getStartMillis();
         if (intervalStart < minTimestamp) {
           log.info("Adding entry [%s] for merge and push.", segment);
@@ -433,14 +433,7 @@ public Void apply(Throwable throwable)
       {
         final List<String> segmentIdentifierStrings = Lists.transform(
             segmentsToPush,
-            new Function<SegmentIdentifier, String>()
-            {
-              @Override
-              public String apply(SegmentIdentifier input)
-              {
-                return input.getIdentifierAsString();
-              }
-            }
+            SegmentIdWithShardSpec::toString
         );
 
         log.makeAlert(throwable, "Failed to publish merged indexes[%s]", schema.getDataSource())
@@ -451,7 +444,7 @@ public String apply(SegmentIdentifier input)
           // We're trying to shut down, and these segments failed to push. Let's just get rid of them.
           // This call will also delete possibly-partially-written files, so we don't need to do it explicitly.
           cleanShutdown = false;
-          for (SegmentIdentifier identifier : segmentsToPush) {
+          for (SegmentIdWithShardSpec identifier : segmentsToPush) {
             dropSegment(identifier);
           }
         }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
index bc8260b38c09..a644e607fd3b 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BaseAppenderatorDriver.java
@@ -192,13 +192,13 @@ static class SegmentsForSequence
       this.lastSegmentId = lastSegmentId;
     }
 
-    void add(SegmentIdentifier identifier)
+    void add(SegmentIdWithShardSpec identifier)
     {
       intervalToSegmentStates.computeIfAbsent(
           identifier.getInterval().getStartMillis(),
           k -> new SegmentsOfInterval(identifier.getInterval())
       ).setAppendingSegment(SegmentWithState.newSegment(identifier));
-      lastSegmentId = identifier.getIdentifierAsString();
+      lastSegmentId = identifier.toString();
     }
 
     Entry<Long, SegmentsOfInterval> floor(long timestamp)
@@ -274,7 +274,7 @@ Map<String, SegmentsForSequence> getSegments()
   /**
    * Find a segment in the {@link SegmentState#APPENDING} state for the given timestamp and sequenceName.
    */
-  private SegmentIdentifier getAppendableSegment(final DateTime timestamp, final String sequenceName)
+  private SegmentIdWithShardSpec getAppendableSegment(final DateTime timestamp, final String sequenceName)
   {
     synchronized (segments) {
       final SegmentsForSequence segmentsForSequence = segments.get(sequenceName);
@@ -314,7 +314,7 @@ private SegmentIdentifier getAppendableSegment(final DateTime timestamp, final S
    *
    * @throws IOException if an exception occurs while allocating a segment
    */
-  private SegmentIdentifier getSegment(
+  private SegmentIdWithShardSpec getSegment(
       final InputRow row,
       final String sequenceName,
       final boolean skipSegmentLineageCheck
@@ -322,13 +322,13 @@ private SegmentIdentifier getSegment(
   {
     synchronized (segments) {
       final DateTime timestamp = row.getTimestamp();
-      final SegmentIdentifier existing = getAppendableSegment(timestamp, sequenceName);
+      final SegmentIdWithShardSpec existing = getAppendableSegment(timestamp, sequenceName);
       if (existing != null) {
         return existing;
       } else {
         // Allocate new segment.
         final SegmentsForSequence segmentsForSequence = segments.get(sequenceName);
-        final SegmentIdentifier newSegment = segmentAllocator.allocate(
+        final SegmentIdWithShardSpec newSegment = segmentAllocator.allocate(
             row,
             sequenceName,
             segmentsForSequence == null ? null : segmentsForSequence.lastSegmentId,
@@ -339,7 +339,7 @@ private SegmentIdentifier getSegment(
         );
 
         if (newSegment != null) {
-          for (SegmentIdentifier identifier : appenderator.getSegments()) {
+          for (SegmentIdWithShardSpec identifier : appenderator.getSegments()) {
             if (identifier.equals(newSegment)) {
               throw new ISE(
                   "WTF?! Allocated segment[%s] which conflicts with existing segment[%s].",
@@ -361,7 +361,7 @@ private SegmentIdentifier getSegment(
     }
   }
 
-  private void addSegment(String sequenceName, SegmentIdentifier identifier)
+  private void addSegment(String sequenceName, SegmentIdWithShardSpec identifier)
   {
     synchronized (segments) {
       segments.computeIfAbsent(sequenceName, k -> new SegmentsForSequence())
@@ -396,7 +396,7 @@ protected AppenderatorDriverAddResult append(
     Preconditions.checkNotNull(row, "row");
     Preconditions.checkNotNull(sequenceName, "sequenceName");
 
-    final SegmentIdentifier identifier = getSegment(row, sequenceName, skipSegmentLineageCheck);
+    final SegmentIdWithShardSpec identifier = getSegment(row, sequenceName, skipSegmentLineageCheck);
 
     if (identifier != null) {
       try {
@@ -461,7 +461,7 @@ Stream<SegmentWithState> getAppendingSegments(Collection<String> sequenceNames)
    */
   ListenableFuture<SegmentsAndMetadata> pushInBackground(
       @Nullable final WrappedCommitter wrappedCommitter,
-      final Collection<SegmentIdentifier> segmentIdentifiers,
+      final Collection<SegmentIdWithShardSpec> segmentIdentifiers,
       final boolean useUniquePath
   )
   {
@@ -471,9 +471,10 @@ ListenableFuture<SegmentsAndMetadata> pushInBackground(
         appenderator.push(segmentIdentifiers, wrappedCommitter, useUniquePath),
         (Function<SegmentsAndMetadata, SegmentsAndMetadata>) segmentsAndMetadata -> {
           // Sanity check
-          final Set<SegmentIdentifier> pushedSegments = segmentsAndMetadata.getSegments().stream()
-                                                                           .map(SegmentIdentifier::fromDataSegment)
-                                                                           .collect(Collectors.toSet());
+          final Set<SegmentIdWithShardSpec> pushedSegments = segmentsAndMetadata.getSegments().stream()
+                                                                                .map(
+                                                                                    SegmentIdWithShardSpec::fromDataSegment)
+                                                                                .collect(Collectors.toSet());
           if (!pushedSegments.equals(Sets.newHashSet(segmentIdentifiers))) {
             log.warn(
                 "Removing segments from deep storage because sanity check failed: %s", segmentsAndMetadata.getSegments()
@@ -509,7 +510,7 @@ ListenableFuture<SegmentsAndMetadata> dropInBackground(SegmentsAndMetadata segme
         segmentsAndMetadata
             .getSegments()
             .stream()
-            .map(segment -> appenderator.drop(SegmentIdentifier.fromDataSegment(segment)))
+            .map(segment -> appenderator.drop(SegmentIdWithShardSpec.fromDataSegment(segment)))
             .collect(Collectors.toList())
     );
 
@@ -565,10 +566,10 @@ ListenableFuture<SegmentsAndMetadata> publishInBackground(
 
                 segmentsAndMetadata.getSegments().forEach(dataSegmentKiller::killQuietly);
 
-                final Set<SegmentIdentifier> segmentsIdentifiers = segmentsAndMetadata
+                final Set<SegmentIdWithShardSpec> segmentsIdentifiers = segmentsAndMetadata
                     .getSegments()
                     .stream()
-                    .map(SegmentIdentifier::fromDataSegment)
+                    .map(SegmentIdWithShardSpec::fromDataSegment)
                     .collect(Collectors.toSet());
 
                 if (usedSegmentChecker.findUsedSegments(segmentsIdentifiers)
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriver.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriver.java
index 2a4547106272..3b084f067b5a 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriver.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriver.java
@@ -129,7 +129,7 @@ private SegmentsAndMetadata pushAndClear(
       long pushAndClearTimeoutMs
   ) throws InterruptedException, ExecutionException, TimeoutException
   {
-    final Map<SegmentIdentifier, SegmentWithState> requestedSegmentIdsForSequences = getAppendingSegments(sequenceNames)
+    final Map<SegmentIdWithShardSpec, SegmentWithState> requestedSegmentIdsForSequences = getAppendingSegments(sequenceNames)
         .collect(Collectors.toMap(SegmentWithState::getSegmentIdentifier, Function.identity()));
 
     final ListenableFuture<SegmentsAndMetadata> future = ListenableFutures.transformAsync(
@@ -142,10 +142,10 @@ private SegmentsAndMetadata pushAndClear(
                                                     future.get(pushAndClearTimeoutMs, TimeUnit.MILLISECONDS);
 
     // Sanity check
-    final Map<SegmentIdentifier, DataSegment> pushedSegmentIdToSegmentMap = segmentsAndMetadata
+    final Map<SegmentIdWithShardSpec, DataSegment> pushedSegmentIdToSegmentMap = segmentsAndMetadata
         .getSegments()
         .stream()
-        .collect(Collectors.toMap(SegmentIdentifier::fromDataSegment, Function.identity()));
+        .collect(Collectors.toMap(SegmentIdWithShardSpec::fromDataSegment, Function.identity()));
 
     if (!pushedSegmentIdToSegmentMap.keySet().equals(requestedSegmentIdsForSequences.keySet())) {
       throw new ISE(
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Committed.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Committed.java
index ba42670bd097..1e22d8572a68 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Committed.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/Committed.java
@@ -46,13 +46,13 @@ public Committed(
   }
 
   public static Committed create(
-      Map<SegmentIdentifier, Integer> hydrants0,
+      Map<SegmentIdWithShardSpec, Integer> hydrants0,
       Object metadata
   )
   {
     final ImmutableMap.Builder<String, Integer> hydrants = ImmutableMap.builder();
-    for (Map.Entry<SegmentIdentifier, Integer> entry : hydrants0.entrySet()) {
-      hydrants.put(entry.getKey().getIdentifierAsString(), entry.getValue());
+    for (Map.Entry<SegmentIdWithShardSpec, Integer> entry : hydrants0.entrySet()) {
+      hydrants.put(entry.getKey().toString(), entry.getValue());
     }
     return new Committed(hydrants.build(), metadata);
   }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentAllocator.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentAllocator.java
index 1c304aeeeeab..3ca0b7765689 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentAllocator.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentAllocator.java
@@ -36,7 +36,7 @@ public interface SegmentAllocator
    *
    * @return the pending segment identifier, or null if it was impossible to allocate a new segment
    */
-  SegmentIdentifier allocate(
+  SegmentIdWithShardSpec allocate(
       InputRow row,
       String sequenceName,
       String previousSegmentId,
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdentifier.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpec.java
similarity index 68%
rename from server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdentifier.java
rename to server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpec.java
index 0c0d35229246..4ea67023144a 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdentifier.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpec.java
@@ -23,56 +23,54 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Preconditions;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.ShardSpec;
 import org.joda.time.Interval;
 
-import java.util.Objects;
-
-public class SegmentIdentifier
+/**
+ * {@link SegmentId} with additional {@link ShardSpec} info. {@link #equals}/{@link #hashCode} and {@link
+ * #compareTo} don't consider that additinal info.
+ */
+public final class SegmentIdWithShardSpec implements Comparable<SegmentIdWithShardSpec>
 {
-  private final String dataSource;
-  private final Interval interval;
-  private final String version;
+  private final SegmentId id;
   private final ShardSpec shardSpec;
   private final String asString;
 
   @JsonCreator
-  public SegmentIdentifier(
+  public SegmentIdWithShardSpec(
       @JsonProperty("dataSource") String dataSource,
       @JsonProperty("interval") Interval interval,
       @JsonProperty("version") String version,
       @JsonProperty("shardSpec") ShardSpec shardSpec
   )
   {
-    this.dataSource = Preconditions.checkNotNull(dataSource, "dataSource");
-    this.interval = Preconditions.checkNotNull(interval, "interval");
-    this.version = Preconditions.checkNotNull(version, "version");
+    this.id = SegmentId.of(dataSource, interval, version, shardSpec.getPartitionNum());
     this.shardSpec = Preconditions.checkNotNull(shardSpec, "shardSpec");
-    this.asString = DataSegment.makeDataSegmentIdentifier(
-        dataSource,
-        interval.getStart(),
-        interval.getEnd(),
-        version,
-        shardSpec
-    );
+    this.asString = id.toString();
+  }
+
+  public SegmentId asSegmentId()
+  {
+    return id;
   }
 
   @JsonProperty
   public String getDataSource()
   {
-    return dataSource;
+    return id.getDataSource();
   }
 
   @JsonProperty
   public Interval getInterval()
   {
-    return interval;
+    return id.getInterval();
   }
 
   @JsonProperty
   public String getVersion()
   {
-    return version;
+    return id.getVersion();
   }
 
   @JsonProperty
@@ -81,28 +79,29 @@ public ShardSpec getShardSpec()
     return shardSpec;
   }
 
-  public String getIdentifierAsString()
-  {
-    return asString;
-  }
-
   @Override
   public boolean equals(Object o)
   {
     if (this == o) {
       return true;
     }
-    if (o == null || getClass() != o.getClass()) {
+    if (!(o instanceof SegmentIdWithShardSpec)) {
       return false;
     }
-    SegmentIdentifier that = (SegmentIdentifier) o;
-    return Objects.equals(asString, that.asString);
+    SegmentIdWithShardSpec that = (SegmentIdWithShardSpec) o;
+    return id.equals(that.id);
   }
 
   @Override
   public int hashCode()
   {
-    return asString.hashCode();
+    return id.hashCode();
+  }
+
+  @Override
+  public int compareTo(SegmentIdWithShardSpec o)
+  {
+    return id.compareTo(o.id);
   }
 
   @Override
@@ -111,9 +110,9 @@ public String toString()
     return asString;
   }
 
-  public static SegmentIdentifier fromDataSegment(final DataSegment segment)
+  public static SegmentIdWithShardSpec fromDataSegment(final DataSegment segment)
   {
-    return new SegmentIdentifier(
+    return new SegmentIdWithShardSpec(
         segment.getDataSource(),
         segment.getInterval(),
         segment.getVersion(),
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentWithState.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentWithState.java
index 7a4019e6f941..32c4528bbccf 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentWithState.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentWithState.java
@@ -63,7 +63,7 @@ public static SegmentState fromString(@JsonProperty String name)
     }
   }
 
-  private final SegmentIdentifier segmentIdentifier;
+  private final SegmentIdWithShardSpec segmentIdentifier;
   private SegmentState state;
 
   /**
@@ -72,21 +72,22 @@ public static SegmentState fromString(@JsonProperty String name)
    */
   @Nullable private DataSegment dataSegment;
 
-  static SegmentWithState newSegment(SegmentIdentifier segmentIdentifier)
+  static SegmentWithState newSegment(SegmentIdWithShardSpec segmentIdentifier)
   {
     return new SegmentWithState(segmentIdentifier, SegmentState.APPENDING, null);
   }
 
-  static SegmentWithState newSegment(SegmentIdentifier segmentIdentifier, SegmentState state)
+  static SegmentWithState newSegment(SegmentIdWithShardSpec segmentIdentifier, SegmentState state)
   {
     return new SegmentWithState(segmentIdentifier, state, null);
   }
 
   @JsonCreator
   public SegmentWithState(
-      @JsonProperty("segmentIdentifier") SegmentIdentifier segmentIdentifier,
+      @JsonProperty("segmentIdentifier") SegmentIdWithShardSpec segmentIdentifier,
       @JsonProperty("state") SegmentState state,
-      @JsonProperty("dataSegment") @Nullable DataSegment dataSegment)
+      @JsonProperty("dataSegment") @Nullable DataSegment dataSegment
+  )
   {
     this.segmentIdentifier = segmentIdentifier;
     this.state = state;
@@ -123,7 +124,7 @@ public void pushAndDrop(DataSegment dataSegment)
   }
 
   @JsonProperty
-  public SegmentIdentifier getSegmentIdentifier()
+  public SegmentIdWithShardSpec getSegmentIdentifier()
   {
     return segmentIdentifier;
   }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
index 53f68f59ef2b..b5b4419d632f 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SinkQuerySegmentWalker.java
@@ -55,6 +55,7 @@
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.realtime.FireHydrant;
 import org.apache.druid.segment.realtime.plumber.Sink;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.PartitionChunk;
@@ -198,12 +199,12 @@ public QueryRunner<T> apply(final SegmentDescriptor descriptor)
                             }
 
                             final Sink theSink = chunk.getObject();
-                            final String sinkSegmentIdentifier = theSink.getSegment().getIdentifier();
+                            final SegmentId sinkSegmentId = theSink.getSegment().getId();
 
                             return new SpecificSegmentQueryRunner<>(
                                 withPerSinkMetrics(
                                     new BySegmentQueryRunner<>(
-                                        sinkSegmentIdentifier,
+                                        sinkSegmentId,
                                         descriptor.getInterval().getStart(),
                                         factory.mergeRunners(
                                             MoreExecutors.sameThreadExecutor(),
@@ -262,7 +263,7 @@ public QueryRunner<T> apply(final FireHydrant hydrant)
                                         )
                                     ),
                                     toolChest,
-                                    sinkSegmentIdentifier,
+                                    sinkSegmentId,
                                     cpuTimeAccumulator
                                 ),
                                 new SpecificSegmentSpec(descriptor)
@@ -286,16 +287,15 @@ public QueryRunner<T> apply(final FireHydrant hydrant)
   private <T> QueryRunner<T> withPerSinkMetrics(
       final QueryRunner<T> sinkRunner,
       final QueryToolChest<T, ? extends Query<T>> queryToolChest,
-      final String sinkSegmentIdentifier,
+      final SegmentId sinkSegmentId,
       final AtomicLong cpuTimeAccumulator
   )
   {
-
     // Note: reportSegmentAndCacheTime and reportSegmentTime are effectively the same here. They don't split apart
     // cache vs. non-cache due to the fact that Sinks may be partially cached and partially uncached. Making this
     // better would need to involve another accumulator like the cpuTimeAccumulator that we could share with the
     // sinkRunner.
-
+    String sinkSegmentIdString = sinkSegmentId.toString();
     return CPUTimeMetricQueryRunner.safeBuild(
         new MetricsEmittingQueryRunner<>(
             emitter,
@@ -305,10 +305,10 @@ private <T> QueryRunner<T> withPerSinkMetrics(
                 queryToolChest,
                 sinkRunner,
                 QueryMetrics::reportSegmentTime,
-                queryMetrics -> queryMetrics.segment(sinkSegmentIdentifier)
+                queryMetrics -> queryMetrics.segment(sinkSegmentIdString)
             ),
             QueryMetrics::reportSegmentAndCacheTime,
-            queryMetrics -> queryMetrics.segment(sinkSegmentIdentifier)
+            queryMetrics -> queryMetrics.segment(sinkSegmentIdString)
         ).withWaitMeasuredFromNow(),
         queryToolChest,
         emitter,
@@ -319,6 +319,6 @@ private <T> QueryRunner<T> withPerSinkMetrics(
 
   public static String makeHydrantCacheIdentifier(FireHydrant input)
   {
-    return input.getSegmentIdentifier() + "_" + input.getCount();
+    return input.getSegmentId() + "_" + input.getCount();
   }
 }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriver.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriver.java
index 95f50b4a8997..0556c49b3653 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriver.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriver.java
@@ -185,7 +185,7 @@ public AppenderatorDriverAddResult add(
    * This method is to support KafkaIndexTask's legacy mode and will be removed in the future.
    * See KakfaIndexTask.runLegacy().
    */
-  public void moveSegmentOut(final String sequenceName, final List<SegmentIdentifier> identifiers)
+  public void moveSegmentOut(final String sequenceName, final List<SegmentIdWithShardSpec> identifiers)
   {
     synchronized (segments) {
       final SegmentsForSequence activeSegmentsForSequence = segments.get(sequenceName);
@@ -193,7 +193,7 @@ public void moveSegmentOut(final String sequenceName, final List<SegmentIdentifi
         throw new ISE("WTF?! Asked to remove segments for sequenceName[%s] which doesn't exist...", sequenceName);
       }
 
-      for (final SegmentIdentifier identifier : identifiers) {
+      for (final SegmentIdWithShardSpec identifier : identifiers) {
         log.info("Moving segment[%s] out of active list.", identifier);
         final long key = identifier.getInterval().getStartMillis();
         final SegmentsOfInterval segmentsOfInterval = activeSegmentsForSequence.get(key);
@@ -264,7 +264,7 @@ public ListenableFuture<SegmentsAndMetadata> publish(
       final Collection<String> sequenceNames
   )
   {
-    final List<SegmentIdentifier> theSegments = getSegmentWithStates(sequenceNames)
+    final List<SegmentIdWithShardSpec> theSegments = getSegmentWithStates(sequenceNames)
         .map(SegmentWithState::getSegmentIdentifier)
         .collect(Collectors.toList());
 
@@ -305,9 +305,10 @@ public ListenableFuture<SegmentsAndMetadata> registerHandoff(SegmentsAndMetadata
       return Futures.immediateFuture(null);
 
     } else {
-      final List<SegmentIdentifier> waitingSegmentIdList = segmentsAndMetadata.getSegments().stream()
-                                                                              .map(SegmentIdentifier::fromDataSegment)
-                                                                              .collect(Collectors.toList());
+      final List<SegmentIdWithShardSpec> waitingSegmentIdList = segmentsAndMetadata.getSegments().stream()
+                                                                                   .map(
+                                                                                       SegmentIdWithShardSpec::fromDataSegment)
+                                                                                   .collect(Collectors.toList());
       final Object metadata = Preconditions.checkNotNull(segmentsAndMetadata.getCommitMetadata(), "commitMetadata");
 
       if (waitingSegmentIdList.isEmpty()) {
@@ -324,7 +325,7 @@ public ListenableFuture<SegmentsAndMetadata> registerHandoff(SegmentsAndMetadata
       final SettableFuture<SegmentsAndMetadata> resultFuture = SettableFuture.create();
       final AtomicInteger numRemainingHandoffSegments = new AtomicInteger(waitingSegmentIdList.size());
 
-      for (final SegmentIdentifier segmentIdentifier : waitingSegmentIdList) {
+      for (final SegmentIdWithShardSpec segmentIdentifier : waitingSegmentIdList) {
         handoffNotifier.registerSegmentHandoffCallback(
             new SegmentDescriptor(
                 segmentIdentifier.getInterval(),
@@ -394,8 +395,8 @@ public void close()
   private static class SegmentsForSequenceBuilder
   {
     // segmentId -> (appendingSegment, appendFinishedSegments)
-    private final NavigableMap<SegmentIdentifier, Pair<SegmentWithState, List<SegmentWithState>>> intervalToSegments =
-        new TreeMap<>(Comparator.comparing(SegmentIdentifier::getInterval, Comparators.intervalsByStartThenEnd()));
+    private final NavigableMap<SegmentIdWithShardSpec, Pair<SegmentWithState, List<SegmentWithState>>> intervalToSegments =
+        new TreeMap<>(Comparator.comparing(SegmentIdWithShardSpec::getInterval, Comparators.intervalsByStartThenEnd()));
     private final String lastSegmentId;
 
     SegmentsForSequenceBuilder(String lastSegmentId)
@@ -405,7 +406,7 @@ private static class SegmentsForSequenceBuilder
 
     void add(SegmentWithState segmentWithState)
     {
-      final SegmentIdentifier identifier = segmentWithState.getSegmentIdentifier();
+      final SegmentIdWithShardSpec identifier = segmentWithState.getSegmentIdentifier();
       final Pair<SegmentWithState, List<SegmentWithState>> pair = intervalToSegments.get(identifier);
       final List<SegmentWithState> appendFinishedSegments = pair == null || pair.rhs == null ?
                                                             new ArrayList<>() :
@@ -432,7 +433,7 @@ void add(SegmentWithState segmentWithState)
     SegmentsForSequence build()
     {
       final NavigableMap<Long, SegmentsOfInterval> map = new TreeMap<>();
-      for (Entry<SegmentIdentifier, Pair<SegmentWithState, List<SegmentWithState>>> entry :
+      for (Entry<SegmentIdWithShardSpec, Pair<SegmentWithState, List<SegmentWithState>>> entry :
           intervalToSegments.entrySet()) {
         map.put(
             entry.getKey().getInterval().getStartMillis(),
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/UsedSegmentChecker.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/UsedSegmentChecker.java
index 47c0087bbaee..29fd6028f824 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/UsedSegmentChecker.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/UsedSegmentChecker.java
@@ -33,5 +33,5 @@ public interface UsedSegmentChecker
    *
    * @return used DataSegments
    */
-  Set<DataSegment> findUsedSegments(Set<SegmentIdentifier> identifiers) throws IOException;
+  Set<DataSegment> findUsedSegments(Set<SegmentIdWithShardSpec> identifiers) throws IOException;
 }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/plumber/FlushingPlumber.java b/server/src/main/java/org/apache/druid/segment/realtime/plumber/FlushingPlumber.java
index ceecde5d040e..e92d723ca4f7 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/plumber/FlushingPlumber.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/plumber/FlushingPlumber.java
@@ -124,7 +124,7 @@ protected void flushAfterDuration(final long truncatedTime, final Sink sink)
   {
     log.info(
         "Abandoning segment %s at %s",
-        sink.getSegment().getIdentifier(),
+        sink.getSegment().getId(),
         DateTimes.nowUtc().plusMillis((int) flushDuration.getMillis())
     );
 
@@ -136,7 +136,7 @@ protected void flushAfterDuration(final long truncatedTime, final Sink sink)
           @Override
           public ScheduledExecutors.Signal call()
           {
-            log.info("Abandoning segment %s", sink.getSegment().getIdentifier());
+            log.info("Abandoning segment %s", sink.getSegment().getId());
             abandonSegment(truncatedTime, sink);
             return ScheduledExecutors.Signal.STOP;
           }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/plumber/RealtimePlumber.java b/server/src/main/java/org/apache/druid/segment/realtime/plumber/RealtimePlumber.java
index 5d9e6222e20c..bffd58077b5c 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/plumber/RealtimePlumber.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/plumber/RealtimePlumber.java
@@ -20,16 +20,15 @@
 package org.apache.druid.segment.realtime.plumber;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.base.Function;
-import com.google.common.base.Joiner;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Stopwatch;
 import com.google.common.base.Supplier;
 import com.google.common.base.Throwables;
+import com.google.common.collect.Collections2;
 import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.primitives.Ints;
+import org.apache.commons.io.FileUtils;
 import org.apache.druid.client.cache.Cache;
 import org.apache.druid.client.cache.CacheConfig;
 import org.apache.druid.client.cache.CachePopulatorStats;
@@ -74,9 +73,9 @@
 import org.apache.druid.segment.realtime.appenderator.SinkQuerySegmentWalker;
 import org.apache.druid.server.coordination.DataSegmentAnnouncer;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.SingleElementPartitionChunk;
-import org.apache.commons.io.FileUtils;
 import org.joda.time.DateTime;
 import org.joda.time.Duration;
 import org.joda.time.Interval;
@@ -452,14 +451,14 @@ public void doRun()
               metrics.incrementMergeCpuTime(VMUtils.safeGetThreadCpuTime() - mergeThreadCpuTime);
               metrics.incrementMergeTimeMillis(mergeStopwatch.elapsed(TimeUnit.MILLISECONDS));
 
-              log.info("Pushing [%s] to deep storage", sink.getSegment().getIdentifier());
+              log.info("Pushing [%s] to deep storage", sink.getSegment().getId());
 
               DataSegment segment = dataSegmentPusher.push(
                   mergedFile,
                   sink.getSegment().withDimensions(IndexMerger.getMergedDimensionsFromQueryableIndexes(indexes)),
                   false
               );
-              log.info("Inserting [%s] to the metadata store", sink.getSegment().getIdentifier());
+              log.info("Inserting [%s] to the metadata store", sink.getSegment().getId());
               segmentPublisher.publishSegment(segment);
 
               if (!isPushedMarker.createNewFile()) {
@@ -521,19 +520,7 @@ public void finishJob()
       try {
         log.info(
             "Cannot shut down yet! Sinks remaining: %s",
-            Joiner.on(", ").join(
-                Iterables.transform(
-                    sinks.values(),
-                    new Function<Sink, String>()
-                    {
-                      @Override
-                      public String apply(Sink input)
-                      {
-                        return input.getSegment().getIdentifier();
-                      }
-                    }
-                )
-            )
+            Collections2.transform(sinks.values(), sink -> sink.getSegment().getId())
         );
 
         synchronized (handoffCondition) {
@@ -709,14 +696,12 @@ public int compare(File o1, File o2)
         hydrants.add(
             new FireHydrant(
                 new QueryableIndexSegment(
-                    DataSegment.makeDataSegmentIdentifier(
+                    queryableIndex, SegmentId.of(
                         schema.getDataSource(),
-                        sinkInterval.getStart(),
-                        sinkInterval.getEnd(),
+                        sinkInterval,
                         versioningPolicy.getVersion(sinkInterval),
                         config.getShardSpec()
-                    ),
-                    queryableIndex
+                    )
                 ),
                 Integer.parseInt(segmentDir.getName())
             )
@@ -891,7 +876,7 @@ protected void abandonSegment(final long truncatedTime, final Sink sink)
       try {
         segmentAnnouncer.unannounceSegment(sink.getSegment());
         removeSegment(sink, computePersistDir(schema, sink.getInterval()));
-        log.info("Removing sinkKey %d for segment %s", truncatedTime, sink.getSegment().getIdentifier());
+        log.info("Removing sinkKey %d for segment %s", truncatedTime, sink.getSegment().getId());
         sinks.remove(truncatedTime);
         metrics.setSinkCount(sinks.size());
         sinkTimeline.remove(
@@ -980,10 +965,7 @@ protected int persistHydrant(
         );
 
         indexToPersist.swapSegment(
-            new QueryableIndexSegment(
-                indexToPersist.getSegmentIdentifier(),
-                indexIO.loadIndex(persistedFile)
-            )
+            new QueryableIndexSegment(indexIO.loadIndex(persistedFile), indexToPersist.getSegmentId())
         );
         return numRows;
       }
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/plumber/Sink.java b/server/src/main/java/org/apache/druid/segment/realtime/plumber/Sink.java
index c11d25ddff15..5b5593ada5b0 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/plumber/Sink.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/plumber/Sink.java
@@ -19,7 +19,6 @@
 
 package org.apache.druid.segment.realtime.plumber;
 
-import com.google.common.base.Function;
 import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterators;
@@ -43,7 +42,6 @@
 import org.apache.druid.timeline.partition.ShardSpec;
 import org.joda.time.Interval;
 
-import javax.annotation.Nullable;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -247,16 +245,7 @@ public DataSegment getSegment()
         version,
         ImmutableMap.of(),
         Lists.newArrayList(),
-        Lists.transform(
-            Arrays.asList(schema.getAggregators()), new Function<AggregatorFactory, String>()
-            {
-              @Override
-              public String apply(@Nullable AggregatorFactory input)
-              {
-                return input.getName();
-              }
-            }
-        ),
+        Lists.transform(Arrays.asList(schema.getAggregators()), AggregatorFactory::getName),
         shardSpec,
         null,
         0
@@ -378,7 +367,7 @@ private FireHydrant makeNewCurrIndex(long minTimestamp, DataSchema schema)
             newIndex.loadDimensionIterable(dimOrder, oldCapabilities);
           }
         }
-        currHydrant = new FireHydrant(newIndex, newCount, getSegment().getIdentifier());
+        currHydrant = new FireHydrant(newIndex, newCount, getSegment().getId());
         if (old != null) {
           numRowsExcludingCurrIndex.addAndGet(old.getIndex().size());
         }
diff --git a/server/src/main/java/org/apache/druid/server/ClientInfoResource.java b/server/src/main/java/org/apache/druid/server/ClientInfoResource.java
index f18799e73fff..4ce290e333a5 100644
--- a/server/src/main/java/org/apache/druid/server/ClientInfoResource.java
+++ b/server/src/main/java/org/apache/druid/server/ClientInfoResource.java
@@ -28,7 +28,6 @@
 import com.google.inject.Inject;
 import com.sun.jersey.spi.container.ResourceFilters;
 import org.apache.druid.client.DruidDataSource;
-import org.apache.druid.client.DruidServer;
 import org.apache.druid.client.FilteredServerInventoryView;
 import org.apache.druid.client.ServerViewUtil;
 import org.apache.druid.client.TimelineServerView;
@@ -67,6 +66,8 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  */
@@ -101,21 +102,6 @@ public ClientInfoResource(
     this.authorizerMapper = authorizerMapper;
   }
 
-  private Map<String, List<DataSegment>> getSegmentsForDatasources()
-  {
-    final Map<String, List<DataSegment>> dataSourceMap = Maps.newHashMap();
-    for (DruidServer server : serverInventoryView.getInventory()) {
-      for (DruidDataSource dataSource : server.getDataSources()) {
-        if (!dataSourceMap.containsKey(dataSource.getName())) {
-          dataSourceMap.put(dataSource.getName(), Lists.newArrayList());
-        }
-        List<DataSegment> segments = dataSourceMap.get(dataSource.getName());
-        segments.addAll(dataSource.getSegments());
-      }
-    }
-    return dataSourceMap;
-  }
-
   @GET
   @Produces(MediaType.APPLICATION_JSON)
   public Iterable<String> getDataSources(@Context final HttpServletRequest request)
@@ -126,12 +112,21 @@ public Iterable<String> getDataSources(@Context final HttpServletRequest request
 
     return AuthorizationUtils.filterAuthorizedResources(
         request,
-        getSegmentsForDatasources().keySet(),
+        getAllDataSources(),
         raGenerator,
         authorizerMapper
     );
   }
 
+  private Set<String> getAllDataSources()
+  {
+    return serverInventoryView
+        .getInventory()
+        .stream()
+        .flatMap(server -> server.getDataSources().stream().map(DruidDataSource::getName))
+        .collect(Collectors.toSet());
+  }
+
   @GET
   @Path("/{dataSourceName}")
   @Produces(MediaType.APPLICATION_JSON)
@@ -144,8 +139,8 @@ public Map<String, Object> getDatasource(
   {
     if (full == null) {
       return ImmutableMap.of(
-          KEY_DIMENSIONS, getDatasourceDimensions(dataSourceName, interval),
-          KEY_METRICS, getDatasourceMetrics(dataSourceName, interval)
+          KEY_DIMENSIONS, getDataSourceDimensions(dataSourceName, interval),
+          KEY_METRICS, getDataSourceMetrics(dataSourceName, interval)
       );
     }
 
@@ -224,19 +219,14 @@ public int compare(Interval o1, Interval o2)
   @Path("/{dataSourceName}/dimensions")
   @Produces(MediaType.APPLICATION_JSON)
   @ResourceFilters(DatasourceResourceFilter.class)
-  public Iterable<String> getDatasourceDimensions(
+  public Iterable<String> getDataSourceDimensions(
       @PathParam("dataSourceName") String dataSourceName,
       @QueryParam("interval") String interval
   )
   {
-    final List<DataSegment> segments = getSegmentsForDatasources().get(dataSourceName);
-    final Set<String> dims = Sets.newHashSet();
-
-    if (segments == null || segments.isEmpty()) {
-      return dims;
-    }
+    final Set<DataSegment> segments = getAllSegmentsForDataSource(dataSourceName);
 
-    Interval theInterval;
+    final Interval theInterval;
     if (interval == null || interval.isEmpty()) {
       DateTime now = getCurrentTime();
       theInterval = new Interval(segmentMetadataQueryConfig.getDefaultHistory(), now);
@@ -244,6 +234,7 @@ public Iterable<String> getDatasourceDimensions(
       theInterval = Intervals.of(interval);
     }
 
+    final Set<String> dims = Sets.newHashSet();
     for (DataSegment segment : segments) {
       if (theInterval.overlaps(segment.getInterval())) {
         dims.addAll(segment.getDimensions());
@@ -257,19 +248,14 @@ public Iterable<String> getDatasourceDimensions(
   @Path("/{dataSourceName}/metrics")
   @Produces(MediaType.APPLICATION_JSON)
   @ResourceFilters(DatasourceResourceFilter.class)
-  public Iterable<String> getDatasourceMetrics(
+  public Iterable<String> getDataSourceMetrics(
       @PathParam("dataSourceName") String dataSourceName,
       @QueryParam("interval") String interval
   )
   {
-    final List<DataSegment> segments = getSegmentsForDatasources().get(dataSourceName);
-    final Set<String> metrics = Sets.newHashSet();
+    final Set<DataSegment> segments = getAllSegmentsForDataSource(dataSourceName);
 
-    if (segments == null || segments.isEmpty()) {
-      return metrics;
-    }
-
-    Interval theInterval;
+    final Interval theInterval;
     if (interval == null || interval.isEmpty()) {
       DateTime now = getCurrentTime();
       theInterval = new Interval(segmentMetadataQueryConfig.getDefaultHistory(), now);
@@ -277,6 +263,7 @@ public Iterable<String> getDatasourceMetrics(
       theInterval = Intervals.of(interval);
     }
 
+    final Set<String> metrics = Sets.newHashSet();
     for (DataSegment segment : segments) {
       if (theInterval.overlaps(segment.getInterval())) {
         metrics.addAll(segment.getMetrics());
@@ -286,6 +273,21 @@ public Iterable<String> getDatasourceMetrics(
     return metrics;
   }
 
+  private Set<DataSegment> getAllSegmentsForDataSource(String dataSourceName)
+  {
+    return serverInventoryView
+        .getInventory()
+        .stream()
+        .flatMap(server -> {
+          DruidDataSource dataSource = server.getDataSource(dataSourceName);
+          if (dataSource == null) {
+            return Stream.empty();
+          }
+          return dataSource.getSegments().stream();
+        })
+        .collect(Collectors.toSet());
+  }
+
   @GET
   @Path("/{dataSourceName}/candidates")
   @Produces(MediaType.APPLICATION_JSON)
diff --git a/server/src/main/java/org/apache/druid/server/SegmentManager.java b/server/src/main/java/org/apache/druid/server/SegmentManager.java
index de77b8b4fd1e..a1975ffb7a8b 100644
--- a/server/src/main/java/org/apache/druid/server/SegmentManager.java
+++ b/server/src/main/java/org/apache/druid/server/SegmentManager.java
@@ -171,7 +171,7 @@ public boolean loadSegment(final DataSegment segment) throws SegmentLoadingExcep
           );
 
           if ((entry != null) && (entry.getChunk(segment.getShardSpec().getPartitionNum()) != null)) {
-            log.warn("Told to load a adapter for a segment[%s] that already exists", segment.getIdentifier());
+            log.warn("Told to load a adapter for a segment[%s] that already exists", segment.getId());
             resultSupplier.set(false);
           } else {
             loadedIntervals.add(
@@ -230,7 +230,7 @@ public void dropSegment(final DataSegment segment)
             if (oldQueryable != null) {
               dataSourceState.removeSegment(segment);
 
-              log.info("Attempting to close segment %s", segment.getIdentifier());
+              log.info("Attempting to close segment %s", segment.getId());
               oldQueryable.close();
             } else {
               log.info(
diff --git a/server/src/main/java/org/apache/druid/server/coordination/BatchDataSegmentAnnouncer.java b/server/src/main/java/org/apache/druid/server/coordination/BatchDataSegmentAnnouncer.java
index 462183d4a094..3479d3c34cfa 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/BatchDataSegmentAnnouncer.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/BatchDataSegmentAnnouncer.java
@@ -115,7 +115,7 @@ public DataSegment apply(DataSegment input)
   public void announceSegment(DataSegment segment) throws IOException
   {
     if (segmentLookup.containsKey(segment)) {
-      log.info("Skipping announcement of segment [%s]. Announcement exists already.", segment.getIdentifier());
+      log.info("Skipping announcement of segment [%s]. Announcement exists already.", segment.getId());
       return;
     }
 
@@ -145,7 +145,7 @@ public void announceSegment(DataSegment segment) throws IOException
 
             log.info(
                 "Announcing segment[%s] at existing path[%s]",
-                toAnnounce.getIdentifier(),
+                toAnnounce.getId(),
                 availableZNode.getPath()
             );
             announcer.update(availableZNode.getPath(), availableZNode.getBytes());
@@ -171,7 +171,7 @@ public void announceSegment(DataSegment segment) throws IOException
         SegmentZNode availableZNode = new SegmentZNode(makeServedSegmentPath());
         availableZNode.addSegment(toAnnounce);
 
-        log.info("Announcing segment[%s] at new path[%s]", toAnnounce.getIdentifier(), availableZNode.getPath());
+        log.info("Announcing segment[%s] at new path[%s]", toAnnounce.getId(), availableZNode.getPath());
         announcer.announce(availableZNode.getPath(), availableZNode.getBytes());
         segmentLookup.put(toAnnounce, availableZNode);
         availableZNodes.add(availableZNode);
@@ -186,7 +186,7 @@ public void unannounceSegment(DataSegment segment)
       final SegmentZNode segmentZNode = segmentLookup.remove(segment);
 
       if (segmentZNode == null) {
-        log.warn("No path to unannounce segment[%s]", segment.getIdentifier());
+        log.warn("No path to unannounce segment[%s]", segment.getId());
         return;
       }
 
@@ -198,7 +198,7 @@ public void unannounceSegment(DataSegment segment)
 
       segmentZNode.removeSegment(segment);
 
-      log.info("Unannouncing segment[%s] at path[%s]", segment.getIdentifier(), segmentZNode.getPath());
+      log.info("Unannouncing segment[%s] at path[%s]", segment.getId(), segmentZNode.getPath());
       if (segmentZNode.getCount() == 0) {
         availableZNodes.remove(segmentZNode);
         announcer.unannounce(segmentZNode.getPath());
@@ -223,7 +223,7 @@ public void announceSegments(Iterable<DataSegment> segments) throws IOException
       for (DataSegment ds : segments) {
 
         if (segmentLookup.containsKey(ds)) {
-          log.info("Skipping announcement of segment [%s]. Announcement exists already.", ds.getIdentifier());
+          log.info("Skipping announcement of segment [%s]. Announcement exists already.", ds.getId());
           return;
         }
 
@@ -252,7 +252,7 @@ public void announceSegments(Iterable<DataSegment> segments) throws IOException
           byteSize = 0;
         }
 
-        log.info("Announcing segment[%s] at path[%s]", segment.getIdentifier(), segmentZNode.getPath());
+        log.info("Announcing segment[%s] at path[%s]", segment.getId(), segmentZNode.getPath());
         segmentLookup.put(segment, segmentZNode);
         batch.add(segment);
         count++;
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestHistory.java b/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestHistory.java
index 59ae39b7c881..424032590b50 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestHistory.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestHistory.java
@@ -25,9 +25,9 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.util.concurrent.AbstractFuture;
 import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.java.util.common.concurrent.Execs;
 import org.apache.druid.utils.CircularBuffer;
 
 import java.util.ArrayList;
@@ -35,16 +35,13 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 
 /**
  * This class keeps a bounded list of segment updates made on the server such as adding/dropping segments.
  *
- * Clients call addSegmentChangeRequest(DataSegmentChangeRequest) or addSegmentChangeRequests(List<DataSegmentChangeRequest>)
- * to add segment updates.
+ * Clients call {@link #addChangeRequest} or {@link #addChangeRequests} to add updates (e. g. of segments).
  *
- * Clients call ListenableFuture<SegmentChangeRequestsSnapshot> getRequestsSince(final Counter counter) to get segment
- * updates since given counter.
+ * Clients call {@link #getRequestsSince} to get updates since given counter.
  */
 public class ChangeRequestHistory<T>
 {
@@ -55,7 +52,7 @@ public class ChangeRequestHistory<T>
   private final CircularBuffer<Holder<T>> changes;
 
   @VisibleForTesting
-  final LinkedHashMap<CustomSettableFuture, Counter> waitingFutures;
+  final LinkedHashMap<CustomSettableFuture<T>, Counter> waitingFutures;
 
   private final ExecutorService singleThreadedExecutor;
   private final Runnable resolveWaitingFuturesRunnable;
@@ -68,26 +65,13 @@ public ChangeRequestHistory()
   public ChangeRequestHistory(int maxSize)
   {
     this.maxSize = maxSize;
-    this.changes = new CircularBuffer(maxSize);
+    this.changes = new CircularBuffer<>(maxSize);
 
     this.waitingFutures = new LinkedHashMap<>();
 
-    this.resolveWaitingFuturesRunnable = new Runnable()
-    {
-      @Override
-      public void run()
-      {
-        resolveWaitingFutures();
-      }
-    };
-
-    this.singleThreadedExecutor = Executors.newSingleThreadExecutor(
-        new ThreadFactoryBuilder().setDaemon(true)
-                                  .setNameFormat(
-                                      "SegmentChangeRequestHistory"
-                                  )
-                                  .build()
-    );
+    this.resolveWaitingFuturesRunnable = this::resolveWaitingFutures;
+
+    this.singleThreadedExecutor = Execs.singleThreaded("SegmentChangeRequestHistory");
   }
 
   /**
@@ -96,7 +80,7 @@ public void run()
   public synchronized void addChangeRequests(List<T> requests)
   {
     for (T request : requests) {
-      changes.add(new Holder(request, getLastCounter().inc()));
+      changes.add(new Holder<>(request, getLastCounter().inc()));
     }
 
     singleThreadedExecutor.execute(resolveWaitingFuturesRunnable);
@@ -111,11 +95,11 @@ public synchronized void addChangeRequest(T request)
   }
 
   /**
-   * Returns a Future that , on completion, returns list of segment updates and associated counter.
+   * Returns a Future that, on completion, returns list of segment updates and associated counter.
    * If there are no update since given counter then Future completion waits till an updates is provided.
    *
-   * If counter is older than max number of changes maintained then SegmentChangeRequestsSnapshot is returned
-   * with resetCounter set to True.
+   * If counter is older than max number of changes maintained then {@link ChangeRequestsSnapshot} is returned
+   * with {@link ChangeRequestsSnapshot#resetCounter} set to True.
    *
    * If there were no updates to provide immediately then a future is created and returned to caller. This future
    * is added to the "waitingFutures" list and all the futures in the list get resolved as soon as a segment
@@ -123,7 +107,7 @@ public synchronized void addChangeRequest(T request)
    */
   public synchronized ListenableFuture<ChangeRequestsSnapshot<T>> getRequestsSince(final Counter counter)
   {
-    final CustomSettableFuture future = new CustomSettableFuture(waitingFutures);
+    final CustomSettableFuture<T> future = new CustomSettableFuture<>(waitingFutures);
 
     if (counter.counter < 0) {
       future.setException(new IAE("counter[%s] must be >= 0", counter));
@@ -134,13 +118,10 @@ public synchronized ListenableFuture<ChangeRequestsSnapshot<T>> getRequestsSince
 
     if (counter.counter == lastCounter.counter) {
       if (!counter.matches(lastCounter)) {
-        future.set(ChangeRequestsSnapshot.fail(
-            StringUtils.format(
-                "counter[%s] failed to match with [%s]",
-                counter,
-                lastCounter
-            )
-        ));
+        ChangeRequestsSnapshot<T> reset = ChangeRequestsSnapshot.fail(
+            StringUtils.format("counter[%s] failed to match with [%s]", counter, lastCounter)
+        );
+        future.set(reset);
       } else {
         synchronized (waitingFutures) {
           waitingFutures.put(future, counter);
@@ -296,7 +277,7 @@ public String toString()
     }
   }
 
-  // Future with cancel() implementation to remove it from "waitingFutures" list
+  /** Future with cancel() implementation to remove it from {@link #waitingFutures} */
   private static class CustomSettableFuture<T> extends AbstractFuture<ChangeRequestsSnapshot<T>>
   {
     private final LinkedHashMap<CustomSettableFuture<T>, Counter> waitingFutures;
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestHttpSyncer.java b/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestHttpSyncer.java
index 1ae2d18397ca..a7a33f977619 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestHttpSyncer.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestHttpSyncer.java
@@ -53,8 +53,9 @@
 
 /**
  * This class facilitates the usage of long-polling HTTP endpoints powered by {@link ChangeRequestHistory}.
- * For example {@link org.apache.druid.client.HttpServerInventoryView} uses it to keep segment state in sync with data nodes
- * which expose the segment state via HTTP endpoint in {@link org.apache.druid.server.http.SegmentListerResource#getSegments}.
+ * For example {@link org.apache.druid.client.HttpServerInventoryView} uses it to keep segment state in sync with data
+ * nodes which expose the segment state via HTTP endpoint in {@link
+ * org.apache.druid.server.http.SegmentListerResource#getSegments}.
  */
 public class ChangeRequestHttpSyncer<T>
 {
@@ -78,11 +79,11 @@ public class ChangeRequestHttpSyncer<T>
 
   private final CountDownLatch initializationLatch = new CountDownLatch(1);
 
-  // This lock is used to ensure proper start-then-stop semantics and
-  // making sure after stopping no state update happens and
-  // sync is not again scheduled in executor and
-  // if there was a previously scheduled sync before stopping, it is skipped and
-  // also, it is used to ensure that duplicate syncs are never scheduled in the executor
+  /**
+   * This lock is used to ensure proper start-then-stop semantics and making sure after stopping no state update happens
+   * and {@link #sync} is not again scheduled in {@link #executor} and if there was a previously scheduled sync before
+   * stopping, it is skipped and also, it is used to ensure that duplicate syncs are never scheduled in the executor.
+   */
   private final LifecycleLock startStopLock = new LifecycleLock();
 
   private final String logIdentity;
@@ -114,7 +115,7 @@ public ChangeRequestHttpSyncer(
     this.serverUnstabilityTimeout = serverUnstabilityTimeout;
     this.serverHttpTimeout = serverTimeoutMS + HTTP_TIMEOUT_EXTRA_MS;
     this.listener = listener;
-    this.logIdentity = StringUtils.format("%s_%s", baseServerURL, System.currentTimeMillis());
+    this.logIdentity = StringUtils.format("%s_%d", baseServerURL, System.currentTimeMillis());
   }
 
   public void start()
@@ -143,10 +144,10 @@ public void stop()
     }
   }
 
-  //wait for first fetch of segment listing from server.
-  public boolean awaitInitialization(long timeoutMS) throws InterruptedException
+  /** Wait for first fetch of segment listing from server. */
+  public boolean awaitInitialization(long timeout, TimeUnit timeUnit) throws InterruptedException
   {
-    return initializationLatch.await(timeoutMS, TimeUnit.MILLISECONDS);
+    return initializationLatch.await(timeout, timeUnit);
   }
 
   /**
@@ -156,10 +157,17 @@ public Map<String, Object> getDebugInfo()
   {
     long currTime = System.currentTimeMillis();
 
-    return ImmutableMap.of("notSyncedForSecs", lastSyncTime == 0 ? "Never Synced" : (currTime - lastSyncTime) / 1000,
-                           "notSuccessfullySyncedFor", lastSuccessfulSyncTime == 0 ? "Never Successfully Synced" : (currTime - lastSuccessfulSyncTime) / 1000,
-                           "consecutiveFailedAttemptCount", consecutiveFailedAttemptCount,
-                           "syncScheduled", startStopLock.isStarted()
+    Object notSuccessfullySyncedFor;
+    if (lastSuccessfulSyncTime == 0) {
+      notSuccessfullySyncedFor = "Never Successfully Synced";
+    } else {
+      notSuccessfullySyncedFor = (currTime - lastSuccessfulSyncTime) / 1000;
+    }
+    return ImmutableMap.of(
+        "notSyncedForSecs", lastSyncTime == 0 ? "Never Synced" : (currTime - lastSyncTime) / 1000,
+        "notSuccessfullySyncedFor", notSuccessfullySyncedFor,
+        "consecutiveFailedAttemptCount", consecutiveFailedAttemptCount,
+        "syncScheduled", startStopLock.isStarted()
     );
   }
 
@@ -188,28 +196,13 @@ private void sync()
     lastSyncTime = System.currentTimeMillis();
 
     try {
-      final String req;
-      if (counter != null) {
-        req = StringUtils.format(
-            "%s?counter=%s&hash=%s&timeout=%s",
-            baseRequestPath,
-            counter.getCounter(),
-            counter.getHash(),
-            serverTimeoutMS
-        );
-      } else {
-        req = StringUtils.format(
-            "%s?counter=-1&timeout=%s",
-            baseRequestPath,
-            serverTimeoutMS
-        );
-      }
+      final String req = getRequestString();
 
       BytesAccumulatingResponseHandler responseHandler = new BytesAccumulatingResponseHandler();
 
       log.debug("Sending sync request to server[%s]", logIdentity);
 
-      ListenableFuture<InputStream> future = httpClient.go(
+      ListenableFuture<InputStream> syncRequestFuture = httpClient.go(
           new Request(HttpMethod.GET, new URL(baseServerURL, req))
               .addHeader(HttpHeaders.Names.ACCEPT, SmileMediaTypes.APPLICATION_JACKSON_SMILE)
               .addHeader(HttpHeaders.Names.CONTENT_TYPE, SmileMediaTypes.APPLICATION_JACKSON_SMILE),
@@ -220,7 +213,7 @@ private void sync()
       log.debug("Sent sync request to [%s]", logIdentity);
 
       Futures.addCallback(
-          future,
+          syncRequestFuture,
           new FutureCallback<InputStream>()
           {
             @Override
@@ -244,26 +237,17 @@ public void onSuccess(InputStream stream)
 
                   log.debug("Received sync response from [%s]", logIdentity);
 
-                  ChangeRequestsSnapshot<T> changes = smileMapper.readValue(
-                      stream,
-                      responseTypeReferences
-                  );
+                  ChangeRequestsSnapshot<T> changes = smileMapper.readValue(stream, responseTypeReferences);
 
                   log.debug("Finished reading sync response from [%s]", logIdentity);
 
                   if (changes.isResetCounter()) {
-                    log.info(
-                        "[%s] requested resetCounter for reason [%s].",
-                        logIdentity,
-                        changes.getResetCause()
-                    );
+                    log.info("[%s] requested resetCounter for reason [%s].", logIdentity, changes.getResetCause());
                     counter = null;
                     return;
                   }
 
                   if (counter == null) {
-                    // means, on last request either server had asked us to reset the counter or it was very first
-                    // request to the server.
                     listener.fullSync(changes.getRequests());
                   } else {
                     listener.deltaSync(changes.getRequests());
@@ -271,7 +255,7 @@ public void onSuccess(InputStream stream)
 
                   counter = changes.getCounter();
 
-                  if (!initializationLatch.await(1, TimeUnit.MILLISECONDS)) {
+                  if (initializationLatch.getCount() > 0) {
                     initializationLatch.countDown();
                     log.info("[%s] synced successfully for the first time.", logIdentity);
                   }
@@ -360,6 +344,23 @@ private void handleFailure(Throwable t)
     }
   }
 
+  private String getRequestString()
+  {
+    final String req;
+    if (counter != null) {
+      req = StringUtils.format(
+          "%s?counter=%s&hash=%s&timeout=%s",
+          baseRequestPath,
+          counter.getCounter(),
+          counter.getHash(),
+          serverTimeoutMS
+      );
+    } else {
+      req = StringUtils.format("%s?counter=-1&timeout=%s", baseRequestPath, serverTimeoutMS);
+    }
+    return req;
+  }
+
   private void addNextSyncToWorkQueue()
   {
     synchronized (startStopLock) {
@@ -375,11 +376,7 @@ private void addNextSyncToWorkQueue()
               RetryUtils.nextRetrySleepMillis(consecutiveFailedAttemptCount)
           );
           log.info("Scheduling next syncup in [%d] millis for server[%s].", sleepMillis, logIdentity);
-          executor.schedule(
-              this::sync,
-              sleepMillis,
-              TimeUnit.MILLISECONDS
-          );
+          executor.schedule(this::sync, sleepMillis, TimeUnit.MILLISECONDS);
         } else {
           executor.execute(this::sync);
         }
@@ -394,14 +391,11 @@ private void addNextSyncToWorkQueue()
         } else {
           log.makeAlert(
               th,
-              "WTF! Couldn't schedule next sync. [%s] is not being synced any more, restarting Druid process on that server might fix the issue.",
+              "WTF! Couldn't schedule next sync. [%s] is not being synced any more, restarting Druid process on that "
+              + "server might fix the issue.",
               logIdentity
           ).emit();
         }
-
-        if (th instanceof InterruptedException) {
-          Thread.currentThread().interrupt();
-        }
       }
     }
   }
@@ -434,8 +428,16 @@ public ClientResponse<AppendableByteArrayInputStream> handleResponse(HttpRespons
     }
   }
 
+  /**
+   * Concurrency guarantees: all calls to {@link #fullSync} and {@link #deltaSync} (that is done within the {@link
+   * #executor}) are linearizable.
+   */
   public interface Listener<T>
   {
+    /**
+     * This method is called either if on the previous request the server had asked to reset the counter or it was the
+     * first request to the server.
+     */
     void fullSync(List<T> changes);
     void deltaSync(List<T> changes);
   }
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestsSnapshot.java b/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestsSnapshot.java
index 96b2a24f8550..bacd53a8c143 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestsSnapshot.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ChangeRequestsSnapshot.java
@@ -26,17 +26,28 @@
 import java.util.List;
 
 /**
- * Return type of SegmentChangeRequestHistory.getRequestsSince(counter).
+ * Return type of {@link ChangeRequestHistory#getRequestsSince}.
  */
-public class ChangeRequestsSnapshot<T>
+public final class ChangeRequestsSnapshot<T>
 {
-  //if true, that means caller should reset the counter and request again.
+
+  public static <T> ChangeRequestsSnapshot<T> success(ChangeRequestHistory.Counter counter, List<T> requests)
+  {
+    return new ChangeRequestsSnapshot<>(false, null, counter, requests);
+  }
+
+  public static <T> ChangeRequestsSnapshot<T> fail(String resetCause)
+  {
+    return new ChangeRequestsSnapshot<>(true, resetCause, null, null);
+  }
+
+  /** if true, that means caller should reset the counter and request again. */
   private final boolean resetCounter;
 
-  //cause for reset if resetCounter is true
+  /** cause for reset if {@link #resetCounter} is true */
   private final String resetCause;
 
-  //segments requests delta since counter, if resetCounter if false
+  /** segments requests delta since counter, if {@link #resetCounter} if false */
   private final ChangeRequestHistory.Counter counter;
   private final List<T> requests;
 
@@ -55,22 +66,10 @@ public ChangeRequestsSnapshot(
       Preconditions.checkNotNull(resetCause, "NULL resetCause when resetCounter is true.");
     }
 
-
     this.counter = counter;
     this.requests = requests;
   }
 
-  public static <T> ChangeRequestsSnapshot<T> success(ChangeRequestHistory.Counter counter,
-                                               List<T> requests)
-  {
-    return new ChangeRequestsSnapshot(false, null, counter, requests);
-  }
-
-  public static <T> ChangeRequestsSnapshot<T> fail(String resetCause)
-  {
-    return new ChangeRequestsSnapshot(true, resetCause, null, null);
-  }
-
   @JsonProperty
   public boolean isResetCounter()
   {
diff --git a/server/src/main/java/org/apache/druid/server/coordination/DruidServerMetadata.java b/server/src/main/java/org/apache/druid/server/coordination/DruidServerMetadata.java
index ff01382ac3b6..e3673bbc9cae 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/DruidServerMetadata.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/DruidServerMetadata.java
@@ -23,6 +23,7 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Preconditions;
 
+import javax.annotation.Nullable;
 import java.util.Objects;
 
 /**
@@ -31,6 +32,7 @@ public class DruidServerMetadata
 {
   private final String name;
   private final String hostAndPort;
+  @Nullable
   private final String hostAndTlsPort;
   private final long maxSize;
   private final String tier;
@@ -41,7 +43,7 @@ public class DruidServerMetadata
   public DruidServerMetadata(
       @JsonProperty("name") String name,
       @JsonProperty("host") String hostAndPort,
-      @JsonProperty("hostAndTlsPort") String hostAndTlsPort,
+      @JsonProperty("hostAndTlsPort") @Nullable String hostAndTlsPort,
       @JsonProperty("maxSize") long maxSize,
       @JsonProperty("type") ServerType type,
       @JsonProperty("tier") String tier,
@@ -74,6 +76,7 @@ public String getHostAndPort()
     return hostAndPort;
   }
 
+  @Nullable
   @JsonProperty
   public String getHostAndTlsPort()
   {
diff --git a/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeRequestDrop.java b/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeRequestDrop.java
index b403d4645170..85c168346242 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeRequestDrop.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeRequestDrop.java
@@ -57,7 +57,7 @@ public void go(DataSegmentChangeHandler handler, DataSegmentChangeCallback callb
   @Override
   public String asString()
   {
-    return StringUtils.format("DROP: %s", segment.getIdentifier());
+    return StringUtils.format("DROP: %s", segment.getId());
   }
 
   @Override
diff --git a/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeRequestLoad.java b/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeRequestLoad.java
index 1a28be8fd43e..002b968256aa 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeRequestLoad.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/SegmentChangeRequestLoad.java
@@ -57,7 +57,7 @@ public DataSegment getSegment()
   @Override
   public String asString()
   {
-    return StringUtils.format("LOAD: %s", segment.getIdentifier());
+    return StringUtils.format("LOAD: %s", segment.getId());
   }
 
   @Override
diff --git a/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java b/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
index 9388bbc24f99..43e201ee8cac 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/SegmentLoadDropHandler.java
@@ -208,15 +208,15 @@ private void loadLocalCache()
       try {
         final DataSegment segment = jsonMapper.readValue(file, DataSegment.class);
 
-        if (!segment.getIdentifier().equals(file.getName())) {
-          log.warn("Ignoring cache file[%s] for segment[%s].", file.getPath(), segment.getIdentifier());
+        if (!segment.getId().toString().equals(file.getName())) {
+          log.warn("Ignoring cache file[%s] for segment[%s].", file.getPath(), segment.getId());
           ignored++;
         } else if (segmentManager.isSegmentCached(segment)) {
           cachedSegments.add(segment);
         } else {
-          log.warn("Unable to find cache file for %s. Deleting lookup entry", segment.getIdentifier());
+          log.warn("Unable to find cache file for %s. Deleting lookup entry", segment.getId());
 
-          File segmentInfoCacheFile = new File(baseDir, segment.getIdentifier());
+          File segmentInfoCacheFile = new File(baseDir, segment.getId().toString());
           if (!segmentInfoCacheFile.delete()) {
             log.warn("Unable to delete segmentInfoCacheFile[%s]", segmentInfoCacheFile);
           }
@@ -262,11 +262,11 @@ private void loadSegment(DataSegment segment, DataSegmentChangeCallback callback
     }
     catch (Exception e) {
       removeSegment(segment, callback, false);
-      throw new SegmentLoadingException(e, "Exception loading segment[%s]", segment.getIdentifier());
+      throw new SegmentLoadingException(e, "Exception loading segment[%s]", segment.getId());
     }
 
     if (loaded) {
-      File segmentInfoCacheFile = new File(config.getInfoDir(), segment.getIdentifier());
+      File segmentInfoCacheFile = new File(config.getInfoDir(), segment.getId().toString());
       if (!segmentInfoCacheFile.exists()) {
         try {
           jsonMapper.writeValue(segmentInfoCacheFile, segment);
@@ -286,7 +286,7 @@ public void addSegment(DataSegment segment, DataSegmentChangeCallback callback)
   {
     Status result = null;
     try {
-      log.info("Loading segment %s", segment.getIdentifier());
+      log.info("Loading segment %s", segment.getId());
       /*
          The lock below is used to prevent a race condition when the scheduled runnable in removeSegment() starts,
          and if (segmentsToDelete.remove(segment)) returns true, in which case historical will start deleting segment
@@ -309,7 +309,7 @@ each time when addSegment() is called, it has to wait for the lock in order to m
         announcer.announceSegment(segment);
       }
       catch (IOException e) {
-        throw new SegmentLoadingException(e, "Failed to announce segment[%s]", segment.getIdentifier());
+        throw new SegmentLoadingException(e, "Failed to announce segment[%s]", segment.getId());
       }
 
       result = Status.SUCCESS;
@@ -352,7 +352,7 @@ public void run()
                       "Loading segment[%d/%d][%s]",
                       counter.incrementAndGet(),
                       numSegments,
-                      segment.getIdentifier()
+                      segment.getId()
                   );
                   loadSegment(segment, callback);
                   try {
@@ -364,7 +364,7 @@ public void run()
                   }
                 }
                 catch (SegmentLoadingException e) {
-                  log.error(e, "[%s] failed to load", segment.getIdentifier());
+                  log.error(e, "[%s] failed to load", segment.getId());
                   failedSegments.add(segment);
                 }
                 finally {
@@ -431,7 +431,7 @@ public void run()
               if (segmentsToDelete.remove(segment)) {
                 segmentManager.dropSegment(segment);
 
-                File segmentInfoCacheFile = new File(config.getInfoDir(), segment.getIdentifier());
+                File segmentInfoCacheFile = new File(config.getInfoDir(), segment.getId().toString());
                 if (!segmentInfoCacheFile.delete()) {
                   log.warn("Unable to delete segmentInfoCacheFile[%s]", segmentInfoCacheFile);
                 }
@@ -449,7 +449,7 @@ public void run()
       if (scheduleDrop) {
         log.info(
             "Completely removing [%s] in [%,d] millis",
-            segment.getIdentifier(),
+            segment.getId(),
             config.getDropSegmentDelayMillis()
         );
         exec.schedule(
diff --git a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
index 8e483479ae00..3605d6ad3dfd 100644
--- a/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
+++ b/server/src/main/java/org/apache/druid/server/coordination/ServerManager.java
@@ -58,6 +58,7 @@
 import org.apache.druid.server.SegmentManager;
 import org.apache.druid.server.SetAndVerifyContextQueryRunner;
 import org.apache.druid.server.initialization.ServerConfig;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.PartitionChunk;
@@ -281,18 +282,19 @@ private <T> QueryRunner<T> buildAndDecorateQueryRunner(
   )
   {
     SpecificSegmentSpec segmentSpec = new SpecificSegmentSpec(segmentDescriptor);
-    String segmentId = adapter.getIdentifier();
+    SegmentId segmentId = adapter.getId();
+    String segmentIdString = segmentId.toString();
 
-    MetricsEmittingQueryRunner metricsEmittingQueryRunnerInner = new MetricsEmittingQueryRunner<>(
+    MetricsEmittingQueryRunner<T> metricsEmittingQueryRunnerInner = new MetricsEmittingQueryRunner<>(
         emitter,
         toolChest,
         new ReferenceCountingSegmentQueryRunner<>(factory, adapter, segmentDescriptor),
         QueryMetrics::reportSegmentTime,
-        queryMetrics -> queryMetrics.segment(segmentId)
+        queryMetrics -> queryMetrics.segment(segmentIdString)
     );
 
-    CachingQueryRunner cachingQueryRunner = new CachingQueryRunner<>(
-        segmentId,
+    CachingQueryRunner<T> cachingQueryRunner = new CachingQueryRunner<>(
+        segmentIdString,
         segmentDescriptor,
         objectMapper,
         cache,
@@ -302,26 +304,26 @@ private <T> QueryRunner<T> buildAndDecorateQueryRunner(
         cacheConfig
     );
 
-    BySegmentQueryRunner bySegmentQueryRunner = new BySegmentQueryRunner<>(
+    BySegmentQueryRunner<T> bySegmentQueryRunner = new BySegmentQueryRunner<>(
         segmentId,
         adapter.getDataInterval().getStart(),
         cachingQueryRunner
     );
 
-    MetricsEmittingQueryRunner metricsEmittingQueryRunnerOuter = new MetricsEmittingQueryRunner<>(
+    MetricsEmittingQueryRunner<T> metricsEmittingQueryRunnerOuter = new MetricsEmittingQueryRunner<>(
         emitter,
         toolChest,
         bySegmentQueryRunner,
         QueryMetrics::reportSegmentAndCacheTime,
-        queryMetrics -> queryMetrics.segment(segmentId)
+        queryMetrics -> queryMetrics.segment(segmentIdString)
     ).withWaitMeasuredFromNow();
 
-    SpecificSegmentQueryRunner specificSegmentQueryRunner = new SpecificSegmentQueryRunner<>(
+    SpecificSegmentQueryRunner<T> specificSegmentQueryRunner = new SpecificSegmentQueryRunner<>(
         metricsEmittingQueryRunnerOuter,
         segmentSpec
     );
 
-    PerSegmentOptimizingQueryRunner perSegmentOptimizingQueryRunner = new PerSegmentOptimizingQueryRunner<>(
+    PerSegmentOptimizingQueryRunner<T> perSegmentOptimizingQueryRunner = new PerSegmentOptimizingQueryRunner<>(
         specificSegmentQueryRunner,
         new PerSegmentQueryOptimizationContext(segmentDescriptor)
     );
diff --git a/server/src/main/java/org/apache/druid/server/coordination/package-info.java b/server/src/main/java/org/apache/druid/server/coordination/package-info.java
new file mode 100644
index 000000000000..b91a652b34de
--- /dev/null
+++ b/server/src/main/java/org/apache/druid/server/coordination/package-info.java
@@ -0,0 +1,23 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+@EverythingIsNonnullByDefault
+package org.apache.druid.server.coordination;
+
+import org.apache.druid.annotations.EverythingIsNonnullByDefault;
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/CostBalancerStrategy.java b/server/src/main/java/org/apache/druid/server/coordinator/CostBalancerStrategy.java
index f7f7420c2566..d15dd7a695a2 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/CostBalancerStrategy.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/CostBalancerStrategy.java
@@ -19,16 +19,15 @@
 
 package org.apache.druid.server.coordinator;
 
-import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;
+import org.apache.commons.math3.util.FastMath;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.emitter.EmittingLogger;
 import org.apache.druid.timeline.DataSegment;
-import org.apache.commons.math3.util.FastMath;
 import org.joda.time.Interval;
 
 import java.util.ArrayList;
@@ -264,7 +263,7 @@ public double calculateInitialTotalCost(final List<ServerHolder> serverHolders)
   {
     double cost = 0;
     for (ServerHolder server : serverHolders) {
-      Iterable<DataSegment> segments = server.getServer().getSegments().values();
+      Iterable<DataSegment> segments = server.getServer().getSegments();
       for (DataSegment s : segments) {
         cost += computeJointSegmentsCost(s, segments);
       }
@@ -286,7 +285,7 @@ public double calculateNormalization(final List<ServerHolder> serverHolders)
   {
     double cost = 0;
     for (ServerHolder server : serverHolders) {
-      for (DataSegment segment : server.getServer().getSegments().values()) {
+      for (DataSegment segment : server.getServer().getSegments()) {
         cost += computeJointSegmentsCost(segment, segment);
       }
     }
@@ -338,10 +337,7 @@ protected double computeCost(
     // the sum of the costs of other (exclusive of the proposalSegment) segments on the server
     cost += computeJointSegmentsCost(
         proposalSegment,
-        Iterables.filter(
-            server.getServer().getSegments().values(),
-            Predicates.not(Predicates.equalTo(proposalSegment))
-        )
+        Iterables.filter(server.getServer().getSegments(), segment -> !proposalSegment.equals(segment))
     );
 
     // plus the costs of segments that will be loaded
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/CuratorLoadQueuePeon.java b/server/src/main/java/org/apache/druid/server/coordinator/CuratorLoadQueuePeon.java
index 25df3586ff23..59f009ef8f1a 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/CuratorLoadQueuePeon.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/CuratorLoadQueuePeon.java
@@ -33,6 +33,7 @@
 import org.apache.curator.framework.CuratorFramework;
 import org.apache.curator.framework.api.CuratorWatcher;
 import org.apache.curator.utils.ZKPaths;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.zookeeper.CreateMode;
 import org.apache.zookeeper.data.Stat;
 
@@ -149,14 +150,11 @@ public int getNumberOfSegmentsInQueue()
   }
 
   @Override
-  public void loadSegment(
-      final DataSegment segment,
-      final LoadPeonCallback callback
-  )
+  public void loadSegment(final DataSegment segment, final LoadPeonCallback callback)
   {
     synchronized (lock) {
       if ((currentlyProcessing != null) &&
-          currentlyProcessing.getSegmentIdentifier().equals(segment.getIdentifier())) {
+          currentlyProcessing.getSegmentId().equals(segment.getId())) {
         if (callback != null) {
           currentlyProcessing.addCallback(callback);
         }
@@ -174,7 +172,7 @@ public void loadSegment(
       }
     }
 
-    log.debug("Asking server peon[%s] to load segment[%s]", basePath, segment.getIdentifier());
+    log.debug("Asking server peon[%s] to load segment[%s]", basePath, segment.getId());
     queuedSize.addAndGet(segment.getSize());
     segmentsToLoad.put(segment, new SegmentHolder(segment, LOAD, Collections.singletonList(callback)));
   }
@@ -187,7 +185,7 @@ public void dropSegment(
   {
     synchronized (lock) {
       if ((currentlyProcessing != null) &&
-          currentlyProcessing.getSegmentIdentifier().equals(segment.getIdentifier())) {
+          currentlyProcessing.getSegmentId().equals(segment.getId())) {
         if (callback != null) {
           currentlyProcessing.addCallback(callback);
         }
@@ -205,7 +203,7 @@ public void dropSegment(
       }
     }
 
-    log.debug("Asking server peon[%s] to drop segment[%s]", basePath, segment.getIdentifier());
+    log.debug("Asking server peon[%s] to drop segment[%s]", basePath, segment.getId());
     segmentsToDrop.put(segment, new SegmentHolder(segment, DROP, Collections.singletonList(callback)));
   }
 
@@ -227,7 +225,7 @@ private void processSegmentChangeRequest()
       log.debug(
           "Server[%s] skipping processSegmentChangeRequest because something is currently loading[%s].",
           basePath,
-          currentlyProcessing.getSegmentIdentifier()
+          currentlyProcessing.getSegmentId()
       );
 
       return;
@@ -235,16 +233,16 @@ private void processSegmentChangeRequest()
 
     if (!segmentsToDrop.isEmpty()) {
       currentlyProcessing = segmentsToDrop.firstEntry().getValue();
-      log.info("Server[%s] dropping [%s]", basePath, currentlyProcessing.getSegmentIdentifier());
+      log.info("Server[%s] dropping [%s]", basePath, currentlyProcessing.getSegmentId());
     } else if (!segmentsToLoad.isEmpty()) {
       currentlyProcessing = segmentsToLoad.firstEntry().getValue();
-      log.info("Server[%s] loading [%s]", basePath, currentlyProcessing.getSegmentIdentifier());
+      log.info("Server[%s] loading [%s]", basePath, currentlyProcessing.getSegmentId());
     } else {
       return;
     }
 
     try {
-      final String path = ZKPaths.makePath(basePath, currentlyProcessing.getSegmentIdentifier());
+      final String path = ZKPaths.makePath(basePath, currentlyProcessing.getSegmentId().toString());
       final byte[] payload = jsonMapper.writeValueAsBytes(currentlyProcessing.getChangeRequest());
       curator.create().withMode(CreateMode.EPHEMERAL).forPath(path, payload);
 
@@ -379,7 +377,7 @@ private void entryRemoved(String path)
         log.warn("Server[%s] an entry[%s] was removed even though it wasn't loading!?", basePath, path);
         return;
       }
-      if (!ZKPaths.getNodeFromPath(path).equals(currentlyProcessing.getSegmentIdentifier())) {
+      if (!ZKPaths.getNodeFromPath(path).equals(currentlyProcessing.getSegmentId().toString())) {
         log.warn(
             "Server[%s] entry [%s] was removed even though it's not what is currently loading[%s]",
             basePath, path, currentlyProcessing
@@ -413,11 +411,7 @@ private static class SegmentHolder
     private final int type;
     private final List<LoadPeonCallback> callbacks = Lists.newArrayList();
 
-    private SegmentHolder(
-        DataSegment segment,
-        int type,
-        Collection<LoadPeonCallback> callbacks
-    )
+    private SegmentHolder(DataSegment segment, int type, Collection<LoadPeonCallback> callbacks)
     {
       this.segment = segment;
       this.type = type;
@@ -437,9 +431,9 @@ public int getType()
       return type;
     }
 
-    public String getSegmentIdentifier()
+    public SegmentId getSegmentId()
     {
-      return segment.getIdentifier();
+      return segment.getId();
     }
 
     public long getSegmentSize()
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/DruidCoordinator.java b/server/src/main/java/org/apache/druid/server/coordinator/DruidCoordinator.java
index 1589c1cee545..05a837f88ebf 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/DruidCoordinator.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/DruidCoordinator.java
@@ -29,6 +29,10 @@
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.inject.Inject;
+import it.unimi.dsi.fastutil.objects.Object2LongMap;
+import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.utils.ZKPaths;
 import org.apache.druid.client.DruidDataSource;
 import org.apache.druid.client.DruidServer;
 import org.apache.druid.client.ImmutableDruidDataSource;
@@ -50,7 +54,6 @@
 import org.apache.druid.java.util.common.concurrent.ScheduledExecutorFactory;
 import org.apache.druid.java.util.common.concurrent.ScheduledExecutors;
 import org.apache.druid.java.util.common.guava.Comparators;
-import org.apache.druid.java.util.common.guava.FunctionalIterable;
 import org.apache.druid.java.util.common.lifecycle.LifecycleStart;
 import org.apache.druid.java.util.common.lifecycle.LifecycleStop;
 import org.apache.druid.java.util.emitter.EmittingLogger;
@@ -71,10 +74,7 @@
 import org.apache.druid.server.initialization.ZkPathsConfig;
 import org.apache.druid.server.lookup.cache.LookupCoordinatorManager;
 import org.apache.druid.timeline.DataSegment;
-import it.unimi.dsi.fastutil.objects.Object2LongMap;
-import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
-import org.apache.curator.framework.CuratorFramework;
-import org.apache.curator.utils.ZKPaths;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTime;
 import org.joda.time.Duration;
 import org.joda.time.Interval;
@@ -247,7 +247,7 @@ public Map<String, LoadQueuePeon> getLoadManagementPeons()
         ((LoadRule) rule)
             .getTieredReplicants()
             .forEach((final String tier, final Integer ruleReplicants) -> {
-              int currentReplicants = segmentReplicantLookup.getLoadedReplicants(segment.getIdentifier(), tier);
+              int currentReplicants = segmentReplicantLookup.getLoadedReplicants(segment.getId(), tier);
               retVal
                   .computeIfAbsent(tier, ignored -> new Object2LongOpenHashMap<>())
                   .addTo(segment.getDataSource(), Math.max(ruleReplicants - currentReplicants, 0));
@@ -268,7 +268,7 @@ public Object2LongMap<String> getSegmentAvailability()
     }
 
     for (DataSegment segment : getAvailableDataSegments()) {
-      if (segmentReplicantLookup.getLoadedReplicants(segment.getIdentifier()) == 0) {
+      if (segmentReplicantLookup.getLoadedReplicants(segment.getId()) == 0) {
         retVal.addTo(segment.getDataSource(), 1);
       } else {
         retVal.addTo(segment.getDataSource(), 0);
@@ -278,19 +278,10 @@ public Object2LongMap<String> getSegmentAvailability()
     return retVal;
   }
 
-  boolean hasLoadPending(final String dataSource)
-  {
-    return loadManagementPeons
-        .values()
-        .stream()
-        .flatMap((final LoadQueuePeon peon) -> peon.getSegmentsToLoad().stream())
-        .anyMatch((final DataSegment segment) -> segment.getDataSource().equals(dataSource));
-  }
-
   public Map<String, Double> getLoadStatus()
   {
     Map<String, Double> loadStatus = Maps.newHashMap();
-    for (ImmutableDruidDataSource dataSource : metadataSegmentManager.getInventory()) {
+    for (ImmutableDruidDataSource dataSource : metadataSegmentManager.getDataSources()) {
       final Set<DataSegment> segments = Sets.newHashSet(dataSource.getSegments());
       final int availableSegmentSize = segments.size();
 
@@ -341,7 +332,7 @@ public CoordinatorCompactionConfig getCompactionConfig()
   public void removeSegment(DataSegment segment)
   {
     log.info("Removing Segment[%s]", segment);
-    metadataSegmentManager.removeSegment(segment.getDataSource(), segment.getIdentifier());
+    metadataSegmentManager.removeSegment(segment.getId());
   }
 
   public String getCurrentLeader()
@@ -363,23 +354,23 @@ public void moveSegment(
       }
       throw new ISE("Cannot move null DataSegment");
     }
-    String segmentName = segment.getIdentifier();
+    SegmentId segmentId = segment.getId();
     try {
       if (fromServer.getMetadata().equals(toServer.getMetadata())) {
-        throw new IAE("Cannot move [%s] to and from the same server [%s]", segmentName, fromServer.getName());
+        throw new IAE("Cannot move [%s] to and from the same server [%s]", segmentId, fromServer.getName());
       }
 
-      ImmutableDruidDataSource dataSource = metadataSegmentManager.getInventoryValue(segment.getDataSource());
+      ImmutableDruidDataSource dataSource = metadataSegmentManager.getDataSource(segment.getDataSource());
       if (dataSource == null) {
-        throw new IAE("Unable to find dataSource for segment [%s] in metadata", segmentName);
+        throw new IAE("Unable to find dataSource for segment [%s] in metadata", segmentId);
       }
 
       // get segment information from MetadataSegmentManager instead of getting it from fromServer's.
       // This is useful when MetadataSegmentManager and fromServer DataSegment's are different for same
       // identifier (say loadSpec differs because of deep storage migration).
-      final DataSegment segmentToLoad = dataSource.getSegment(segment.getIdentifier());
+      final DataSegment segmentToLoad = dataSource.getSegment(segment.getId());
       if (segmentToLoad == null) {
-        throw new IAE("No segment metadata found for segment Id [%s]", segment.getIdentifier());
+        throw new IAE("No segment metadata found for segment Id [%s]", segment.getId());
       }
       final LoadQueuePeon loadPeon = loadManagementPeons.get(toServer.getName());
       if (loadPeon == null) {
@@ -402,12 +393,8 @@ public void moveSegment(
         );
       }
 
-      final String toLoadQueueSegPath = ZKPaths.makePath(
-          ZKPaths.makePath(
-              zkPaths.getLoadQueuePath(),
-              toServer.getName()
-          ), segmentName
-      );
+      final String toLoadQueueSegPath =
+          ZKPaths.makePath(zkPaths.getLoadQueuePath(), toServer.getName(), segmentId.toString());
 
       final LoadPeonCallback loadPeonCallback = () -> {
         dropPeon.unmarkSegmentToDrop(segmentToLoad);
@@ -444,7 +431,7 @@ public void moveSegment(
       }
     }
     catch (Exception e) {
-      log.makeAlert(e, "Exception moving segment %s", segmentName).emit();
+      log.makeAlert(e, "Exception moving segment %s", segmentId).emit();
       if (callback != null) {
         callback.execute();
       }
@@ -471,7 +458,7 @@ public Set<DataSegment> getOrderedAvailableDataSegments()
 
   private List<DataSegment> getAvailableDataSegments()
   {
-    return metadataSegmentManager.getInventory()
+    return metadataSegmentManager.getDataSources()
                                  .stream()
                                  .flatMap(source -> source.getSegments().stream())
                                  .collect(Collectors.toList());
@@ -665,7 +652,7 @@ public void run()
         DruidCoordinatorRuntimeParams params =
             DruidCoordinatorRuntimeParams.newBuilder()
                                          .withStartTime(startTime)
-                                         .withDataSources(metadataSegmentManager.getInventory())
+                                         .withDataSources(metadataSegmentManager.getDataSources())
                                          .withDynamicConfigs(getDynamicConfigs())
                                          .withCompactionConfig(getCompactionConfig())
                                          .withEmitter(emitter)
@@ -698,10 +685,12 @@ public CoordinatorHistoricalManagerRunnable(final int startingLeaderCounter)
               new DruidCoordinatorSegmentInfoLoader(DruidCoordinator.this),
               params -> {
                 // Display info about all historical servers
-                Iterable<ImmutableDruidServer> servers = FunctionalIterable
-                    .create(serverInventoryView.getInventory())
+                Iterable<ImmutableDruidServer> servers = serverInventoryView
+                    .getInventory()
+                    .stream()
                     .filter(DruidServer::segmentReplicatable)
-                    .transform(DruidServer::toImmutableDruidServer);
+                    .map(DruidServer::toImmutableDruidServer)
+                    .collect(Collectors.toList());
 
                 if (log.isDebugEnabled()) {
                   log.debug("Servers");
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/HttpLoadQueuePeon.java b/server/src/main/java/org/apache/druid/server/coordinator/HttpLoadQueuePeon.java
index e6faec51c185..f081df8401c0 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/HttpLoadQueuePeon.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/HttpLoadQueuePeon.java
@@ -381,7 +381,7 @@ public void loadSegment(DataSegment segment, LoadPeonCallback callback)
         log.warn(
             "Server[%s] cannot load segment[%s] because load queue peon is stopped.",
             serverId,
-            segment.getIdentifier()
+            segment.getId()
         );
         callback.execute();
         return;
@@ -390,7 +390,7 @@ public void loadSegment(DataSegment segment, LoadPeonCallback callback)
       SegmentHolder holder = segmentsToLoad.get(segment);
 
       if (holder == null) {
-        log.debug("Server[%s] to load segment[%s] queued.", serverId, segment.getIdentifier());
+        log.debug("Server[%s] to load segment[%s] queued.", serverId, segment.getId());
         segmentsToLoad.put(segment, new LoadSegmentHolder(segment, callback));
         processingExecutor.execute(this::doSegmentManagement);
       } else {
@@ -407,7 +407,7 @@ public void dropSegment(DataSegment segment, LoadPeonCallback callback)
         log.warn(
             "Server[%s] cannot drop segment[%s] because load queue peon is stopped.",
             serverId,
-            segment.getIdentifier()
+            segment.getId()
         );
         callback.execute();
         return;
@@ -415,7 +415,7 @@ public void dropSegment(DataSegment segment, LoadPeonCallback callback)
       SegmentHolder holder = segmentsToDrop.get(segment);
 
       if (holder == null) {
-        log.debug("Server[%s] to drop segment[%s] queued.", serverId, segment.getIdentifier());
+        log.debug("Server[%s] to drop segment[%s] queued.", serverId, segment.getId());
         segmentsToDrop.put(segment, new DropSegmentHolder(segment, callback));
         processingExecutor.execute(this::doSegmentManagement);
       } else {
@@ -531,7 +531,7 @@ public void requestSucceeded()
       log.info(
           "Server[%s] Successfully processed segment[%s] request[%s].",
           serverId,
-          segment.getIdentifier(),
+          segment.getId(),
           changeRequest.getClass().getSimpleName()
       );
 
@@ -549,7 +549,7 @@ public void requestFailed(String failureCause)
       log.error(
           "Server[%s] Failed segment[%s] request[%s] with cause [%s].",
           serverId,
-          segment.getIdentifier(),
+          segment.getId(),
           changeRequest.getClass().getSimpleName(),
           failureCause
       );
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/ReplicationThrottler.java b/server/src/main/java/org/apache/druid/server/coordinator/ReplicationThrottler.java
index 8935f093f467..49d1e94fee5a 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/ReplicationThrottler.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/ReplicationThrottler.java
@@ -23,6 +23,7 @@
 import com.google.common.collect.Maps;
 import org.apache.druid.java.util.emitter.EmittingLogger;
 import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.timeline.SegmentId;
 
 import java.util.List;
 import java.util.Map;
@@ -89,43 +90,40 @@ public boolean canCreateReplicant(String tier)
     return replicatingLookup.get(tier) && !currentlyReplicating.isAtMaxReplicants(tier);
   }
 
-  public void registerReplicantCreation(String tier, String segmentId, String serverId)
+  public void registerReplicantCreation(String tier, SegmentId segmentId, String serverId)
   {
     currentlyReplicating.addSegment(tier, segmentId, serverId);
   }
 
-  public void unregisterReplicantCreation(String tier, String segmentId, String serverId)
+  public void unregisterReplicantCreation(String tier, SegmentId segmentId)
   {
-    currentlyReplicating.removeSegment(tier, segmentId, serverId);
+    currentlyReplicating.removeSegment(tier, segmentId);
   }
 
   private class ReplicatorSegmentHolder
   {
-    private final Map<String, ConcurrentHashMap<String, String>> currentlyProcessingSegments = Maps.newHashMap();
+    private final Map<String, ConcurrentHashMap<SegmentId, String>> currentlyProcessingSegments = Maps.newHashMap();
     private final Map<String, Integer> lifetimes = Maps.newHashMap();
 
     public boolean isAtMaxReplicants(String tier)
     {
-      final ConcurrentHashMap<String, String> segments = currentlyProcessingSegments.get(tier);
+      final ConcurrentHashMap<SegmentId, String> segments = currentlyProcessingSegments.get(tier);
       return (segments != null && segments.size() >= maxReplicants);
     }
 
-    public void addSegment(String tier, String segmentId, String serverId)
+    public void addSegment(String tier, SegmentId segmentId, String serverId)
     {
-      ConcurrentHashMap<String, String> segments = currentlyProcessingSegments.get(tier);
-      if (segments == null) {
-        segments = new ConcurrentHashMap<String, String>();
-        currentlyProcessingSegments.put(tier, segments);
-      }
+      ConcurrentHashMap<SegmentId, String> segments =
+          currentlyProcessingSegments.computeIfAbsent(tier, t -> new ConcurrentHashMap<>());
 
       if (!isAtMaxReplicants(tier)) {
         segments.put(segmentId, serverId);
       }
     }
 
-    public void removeSegment(String tier, String segmentId, String serverId)
+    public void removeSegment(String tier, SegmentId segmentId)
     {
-      Map<String, String> segments = currentlyProcessingSegments.get(tier);
+      Map<SegmentId, String> segments = currentlyProcessingSegments.get(tier);
       if (segments != null) {
         segments.remove(segmentId);
       }
@@ -133,28 +131,27 @@ public void removeSegment(String tier, String segmentId, String serverId)
 
     public int getNumProcessing(String tier)
     {
-      Map<String, String> segments = currentlyProcessingSegments.get(tier);
+      Map<SegmentId, String> segments = currentlyProcessingSegments.get(tier);
       return (segments == null) ? 0 : segments.size();
     }
 
     public int getLifetime(String tier)
     {
-      Integer lifetime = lifetimes.get(tier);
-      if (lifetime == null) {
-        lifetime = maxLifetime;
-        lifetimes.put(tier, lifetime);
-      }
-      return lifetime;
+      Integer lifetime = lifetimes.putIfAbsent(tier, maxLifetime);
+      return lifetime != null ? lifetime : maxLifetime;
     }
 
     public void reduceLifetime(String tier)
     {
-      Integer lifetime = lifetimes.get(tier);
-      if (lifetime == null) {
-        lifetime = maxLifetime;
-        lifetimes.put(tier, lifetime);
-      }
-      lifetimes.put(tier, --lifetime);
+      lifetimes.compute(
+          tier,
+          (t, lifetime) -> {
+            if (lifetime == null) {
+              return maxLifetime - 1;
+            }
+            return lifetime - 1;
+          }
+      );
     }
 
     public void resetLifetime(String tier)
@@ -164,13 +161,9 @@ public void resetLifetime(String tier)
 
     public List<String> getCurrentlyProcessingSegmentsAndHosts(String tier)
     {
-      Map<String, String> segments = currentlyProcessingSegments.get(tier);
+      Map<SegmentId, String> segments = currentlyProcessingSegments.get(tier);
       List<String> retVal = Lists.newArrayList();
-      for (Map.Entry<String, String> entry : segments.entrySet()) {
-        retVal.add(
-            StringUtils.format("%s ON %s", entry.getKey(), entry.getValue())
-        );
-      }
+      segments.forEach((segmentId, serverId) -> retVal.add(StringUtils.format("%s ON %s", segmentId, serverId)));
       return retVal;
     }
   }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/ReservoirSegmentSampler.java b/server/src/main/java/org/apache/druid/server/coordinator/ReservoirSegmentSampler.java
index d4b222fe1999..0402c9e23459 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/ReservoirSegmentSampler.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/ReservoirSegmentSampler.java
@@ -34,7 +34,7 @@ static BalancerSegmentHolder getRandomBalancerSegmentHolder(final List<ServerHol
     int numSoFar = 0;
 
     for (ServerHolder server : serverHolders) {
-      for (DataSegment segment : server.getServer().getSegments().values()) {
+      for (DataSegment segment : server.getServer().getSegments()) {
         int randNum = ThreadLocalRandom.current().nextInt(numSoFar + 1);
         // w.p. 1 / (numSoFar+1), swap out the server and segment
         if (randNum == numSoFar) {
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/SegmentReplicantLookup.java b/server/src/main/java/org/apache/druid/server/coordinator/SegmentReplicantLookup.java
index b5e01565a70a..cc475222b2ee 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/SegmentReplicantLookup.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/SegmentReplicantLookup.java
@@ -24,6 +24,7 @@
 import com.google.common.collect.Table;
 import org.apache.druid.client.ImmutableDruidServer;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 import java.util.Map;
 import java.util.SortedSet;
@@ -35,28 +36,28 @@ public class SegmentReplicantLookup
 {
   public static SegmentReplicantLookup make(DruidCluster cluster)
   {
-    final Table<String, String, Integer> segmentsInCluster = HashBasedTable.create();
-    final Table<String, String, Integer> loadingSegments = HashBasedTable.create();
+    final Table<SegmentId, String, Integer> segmentsInCluster = HashBasedTable.create();
+    final Table<SegmentId, String, Integer> loadingSegments = HashBasedTable.create();
 
     for (SortedSet<ServerHolder> serversByType : cluster.getSortedHistoricalsByTier()) {
       for (ServerHolder serverHolder : serversByType) {
         ImmutableDruidServer server = serverHolder.getServer();
 
-        for (DataSegment segment : server.getSegments().values()) {
-          Integer numReplicants = segmentsInCluster.get(segment.getIdentifier(), server.getTier());
+        for (DataSegment segment : server.getSegments()) {
+          Integer numReplicants = segmentsInCluster.get(segment.getId(), server.getTier());
           if (numReplicants == null) {
             numReplicants = 0;
           }
-          segmentsInCluster.put(segment.getIdentifier(), server.getTier(), ++numReplicants);
+          segmentsInCluster.put(segment.getId(), server.getTier(), ++numReplicants);
         }
 
         // Also account for queued segments
         for (DataSegment segment : serverHolder.getPeon().getSegmentsToLoad()) {
-          Integer numReplicants = loadingSegments.get(segment.getIdentifier(), server.getTier());
+          Integer numReplicants = loadingSegments.get(segment.getId(), server.getTier());
           if (numReplicants == null) {
             numReplicants = 0;
           }
-          loadingSegments.put(segment.getIdentifier(), server.getTier(), ++numReplicants);
+          loadingSegments.put(segment.getId(), server.getTier(), ++numReplicants);
         }
       }
     }
@@ -64,23 +65,25 @@ public static SegmentReplicantLookup make(DruidCluster cluster)
     return new SegmentReplicantLookup(segmentsInCluster, loadingSegments);
   }
 
-  private final Table<String, String, Integer> segmentsInCluster;
+  private final Table<SegmentId, String, Integer> segmentsInCluster;
+  private final Table<SegmentId, String, Integer> loadingSegments;
 
-  private final Table<String, String, Integer> loadingSegments;
-
-  private SegmentReplicantLookup(Table<String, String, Integer> segmentsInCluster, Table<String, String, Integer> loadingSegments)
+  private SegmentReplicantLookup(
+      Table<SegmentId, String, Integer> segmentsInCluster,
+      Table<SegmentId, String, Integer> loadingSegments
+  )
   {
     this.segmentsInCluster = segmentsInCluster;
     this.loadingSegments = loadingSegments;
   }
 
-  public Map<String, Integer> getClusterTiers(String segmentId)
+  public Map<String, Integer> getClusterTiers(SegmentId segmentId)
   {
     Map<String, Integer> retVal = segmentsInCluster.row(segmentId);
     return (retVal == null) ? Maps.newHashMap() : retVal;
   }
 
-  public int getLoadedReplicants(String segmentId)
+  int getLoadedReplicants(SegmentId segmentId)
   {
     Map<String, Integer> allTiers = segmentsInCluster.row(segmentId);
     int retVal = 0;
@@ -90,19 +93,19 @@ public int getLoadedReplicants(String segmentId)
     return retVal;
   }
 
-  public int getLoadedReplicants(String segmentId, String tier)
+  int getLoadedReplicants(SegmentId segmentId, String tier)
   {
     Integer retVal = segmentsInCluster.get(segmentId, tier);
     return (retVal == null) ? 0 : retVal;
   }
 
-  public int getLoadingReplicants(String segmentId, String tier)
+  private int getLoadingReplicants(SegmentId segmentId, String tier)
   {
     Integer retVal = loadingSegments.get(segmentId, tier);
     return (retVal == null) ? 0 : retVal;
   }
 
-  public int getLoadingReplicants(String segmentId)
+  private int getLoadingReplicants(SegmentId segmentId)
   {
     Map<String, Integer> allTiers = loadingSegments.row(segmentId);
     int retVal = 0;
@@ -112,12 +115,12 @@ public int getLoadingReplicants(String segmentId)
     return retVal;
   }
 
-  public int getTotalReplicants(String segmentId)
+  public int getTotalReplicants(SegmentId segmentId)
   {
     return getLoadedReplicants(segmentId) + getLoadingReplicants(segmentId);
   }
 
-  public int getTotalReplicants(String segmentId, String tier)
+  public int getTotalReplicants(SegmentId segmentId, String tier)
   {
     return getLoadedReplicants(segmentId, tier) + getLoadingReplicants(segmentId, tier);
   }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/ServerHolder.java b/server/src/main/java/org/apache/druid/server/coordinator/ServerHolder.java
index ab07cc689915..fd1370aa38ef 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/ServerHolder.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/ServerHolder.java
@@ -19,7 +19,6 @@
 
 package org.apache.druid.server.coordinator;
 
-import com.google.common.primitives.Longs;
 import org.apache.druid.client.ImmutableDruidServer;
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.timeline.DataSegment;
@@ -34,10 +33,7 @@ public class ServerHolder implements Comparable<ServerHolder>
   private final ImmutableDruidServer server;
   private final LoadQueuePeon peon;
 
-  public ServerHolder(
-      ImmutableDruidServer server,
-      LoadQueuePeon peon
-  )
+  public ServerHolder(ImmutableDruidServer server, LoadQueuePeon peon)
   {
     this.server = server;
     this.peon = peon;
@@ -99,7 +95,7 @@ public long getAvailableSize()
 
   public boolean isServingSegment(DataSegment segment)
   {
-    return (server.getSegment(segment.getIdentifier()) != null);
+    return server.getSegment(segment.getId()) != null;
   }
 
   public boolean isLoadingSegment(DataSegment segment)
@@ -115,7 +111,7 @@ public int getNumberOfSegmentsInQueue()
   @Override
   public int compareTo(ServerHolder serverHolder)
   {
-    int result = Longs.compare(getAvailableSize(), serverHolder.getAvailableSize());
+    int result = Long.compare(getAvailableSize(), serverHolder.getAvailableSize());
     if (result != 0) {
       return result;
     }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorBalancer.java b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorBalancer.java
index 97589c9bec0d..19d6ccd8a1a1 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorBalancer.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorBalancer.java
@@ -32,6 +32,7 @@
 import org.apache.druid.server.coordinator.LoadQueuePeon;
 import org.apache.druid.server.coordinator.ServerHolder;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 import java.util.Comparator;
 import java.util.HashMap;
@@ -53,7 +54,7 @@ public class DruidCoordinatorBalancer implements DruidCoordinatorHelper
 
   protected final DruidCoordinator coordinator;
 
-  protected final Map<String, ConcurrentHashMap<String, BalancerSegmentHolder>> currentlyMovingSegments =
+  protected final Map<String, ConcurrentHashMap<SegmentId, BalancerSegmentHolder>> currentlyMovingSegments =
       new HashMap<>();
 
   public DruidCoordinatorBalancer(
@@ -69,7 +70,7 @@ protected void reduceLifetimes(String tier)
       holder.reduceLifetime();
       if (holder.getLifetime() <= 0) {
         log.makeAlert("[%s]: Balancer move segments queue has a segment stuck", tier)
-           .addData("segment", holder.getSegment().getIdentifier())
+           .addData("segment", holder.getSegment().getId())
            .addData("server", holder.getFromServer().getMetadata())
            .emit();
       }
@@ -155,13 +156,13 @@ private void balanceTier(
             moveSegment(segmentToMoveHolder, destinationHolder.getServer(), params);
             moved++;
           } else {
-            log.info("Segment [%s] is 'optimally' placed.", segmentToMove.getIdentifier());
+            log.info("Segment [%s] is 'optimally' placed.", segmentToMove.getId());
             unmoved++;
           }
         } else {
           log.info(
               "No valid movement destinations for segment [%s].",
-              segmentToMove.getIdentifier()
+              segmentToMove.getId()
           );
           unmoved++;
         }
@@ -202,18 +203,18 @@ protected void moveSegment(
 
     final ImmutableDruidServer fromServer = segment.getFromServer();
     final DataSegment segmentToMove = segment.getSegment();
-    final String segmentName = segmentToMove.getIdentifier();
+    final SegmentId segmentId = segmentToMove.getId();
 
     if (!toPeon.getSegmentsToLoad().contains(segmentToMove) &&
-        (toServer.getSegment(segmentName) == null) &&
+        (toServer.getSegment(segmentId) == null) &&
         new ServerHolder(toServer, toPeon).getAvailableSize() > segmentToMove.getSize()) {
-      log.info("Moving [%s] from [%s] to [%s]", segmentName, fromServer.getName(), toServer.getName());
+      log.info("Moving [%s] from [%s] to [%s]", segmentId, fromServer.getName(), toServer.getName());
 
       LoadPeonCallback callback = null;
       try {
-        Map<String, BalancerSegmentHolder> movingSegments = currentlyMovingSegments.get(toServer.getTier());
-        movingSegments.put(segmentName, segment);
-        callback = () -> movingSegments.remove(segmentName);
+        Map<SegmentId, BalancerSegmentHolder> movingSegments = currentlyMovingSegments.get(toServer.getTier());
+        movingSegments.put(segmentId, segment);
+        callback = () -> movingSegments.remove(segmentId);
         coordinator.moveSegment(
             fromServer,
             toServer,
@@ -222,7 +223,7 @@ protected void moveSegment(
         );
       }
       catch (Exception e) {
-        log.makeAlert(e, StringUtils.format("[%s] : Moving exception", segmentName)).emit();
+        log.makeAlert(e, StringUtils.format("[%s] : Moving exception", segmentId)).emit();
         if (callback != null) {
           callback.execute();
         }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorCleanupUnneeded.java b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorCleanupUnneeded.java
index f7604835a253..ad5df3d4241b 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorCleanupUnneeded.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorCleanupUnneeded.java
@@ -79,7 +79,7 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
                   stats.addToTieredStat("unneededCount", server.getTier(), 1);
                   log.info(
                       "Dropping uneeded segment [%s] from server [%s] in tier [%s]",
-                      segment.getIdentifier(),
+                      segment.getId(),
                       server.getName(),
                       server.getTier()
                   );
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorLogger.java b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorLogger.java
index f56a3d7489af..065ca1606317 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorLogger.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorLogger.java
@@ -289,16 +289,12 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
         .forEach((final String name, final List<DataSegment> segments) -> {
           final long size = segments.stream().mapToLong(DataSegment::getSize).sum();
           emitter.emit(
-              new ServiceMetricEvent.Builder()
-                  .setDimension(DruidMetrics.DATASOURCE, name).build(
-                  "segment/size", size
-              )
+              new ServiceMetricEvent.Builder().setDimension(DruidMetrics.DATASOURCE, name).build("segment/size", size)
           );
           emitter.emit(
               new ServiceMetricEvent.Builder()
-                  .setDimension(DruidMetrics.DATASOURCE, name).build(
-                  "segment/count", segments.size()
-              )
+                  .setDimension(DruidMetrics.DATASOURCE, name)
+                  .build("segment/count", segments.size())
           );
         });
 
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorRuleRunner.java b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorRuleRunner.java
index 82681c64921a..524797d9170d 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorRuleRunner.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorRuleRunner.java
@@ -31,6 +31,7 @@
 import org.apache.druid.server.coordinator.ReplicationThrottler;
 import org.apache.druid.server.coordinator.rules.Rule;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.joda.time.DateTime;
@@ -130,7 +131,7 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
     DateTime now = DateTimes.nowUtc();
     MetadataRuleManager databaseRuleManager = paramsWithReplicationManager.getDatabaseRuleManager();
 
-    final List<String> segmentsWithMissingRules = Lists.newArrayListWithCapacity(MAX_MISSING_RULES);
+    final List<SegmentId> segmentsWithMissingRules = Lists.newArrayListWithCapacity(MAX_MISSING_RULES);
     int missingRules = 0;
     for (DataSegment segment : paramsWithReplicationManager.getAvailableSegments()) {
       List<Rule> rules = databaseRuleManager.getRulesWithDefault(segment.getDataSource());
@@ -145,7 +146,7 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
 
       if (!foundMatchingRule) {
         if (segmentsWithMissingRules.size() < MAX_MISSING_RULES) {
-          segmentsWithMissingRules.add(segment.getIdentifier());
+          segmentsWithMissingRules.add(segment.getId());
         }
         missingRules++;
       }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorSegmentKiller.java b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorSegmentKiller.java
index 7030e3e6dda1..e8b774dcc9a9 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorSegmentKiller.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorSegmentKiller.java
@@ -92,7 +92,7 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
     }
 
     if (killAllDataSources) {
-      whitelist = segmentManager.getAllDatasourceNames();
+      whitelist = segmentManager.getAllDataSourceNames();
     }
 
     if (whitelist != null && whitelist.size() > 0 && (lastKillTime + period) < System.currentTimeMillis()) {
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorSegmentMerger.java b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorSegmentMerger.java
index 7486dcea22e0..a6e10a3a22bb 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorSegmentMerger.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorSegmentMerger.java
@@ -29,7 +29,6 @@
 import com.google.common.collect.Multiset;
 import com.google.common.collect.Ordering;
 import com.google.inject.Inject;
-import org.apache.druid.java.util.emitter.service.ServiceMetricEvent;
 import org.apache.druid.client.indexing.IndexingServiceClient;
 import org.apache.druid.common.config.JacksonConfigManager;
 import org.apache.druid.java.util.common.DateTimes;
@@ -37,10 +36,12 @@
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.guava.FunctionalIterable;
 import org.apache.druid.java.util.common.logger.Logger;
+import org.apache.druid.java.util.emitter.service.ServiceMetricEvent;
 import org.apache.druid.server.coordinator.CoordinatorStats;
 import org.apache.druid.server.coordinator.DatasourceWhitelist;
 import org.apache.druid.server.coordinator.DruidCoordinatorRuntimeParams;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.NoneShardSpec;
@@ -152,17 +153,7 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
   private int mergeSegments(SegmentsToMerge segmentsToMerge, String dataSource)
   {
     final List<DataSegment> segments = segmentsToMerge.getSegments();
-    final List<String> segmentNames = Lists.transform(
-        segments,
-        new Function<DataSegment, String>()
-        {
-          @Override
-          public String apply(DataSegment input)
-          {
-            return input.getIdentifier();
-          }
-        }
-    );
+    final List<SegmentId> segmentNames = Lists.transform(segments, DataSegment::getId);
 
     log.info("[%s] Found %d segments to merge %s", dataSource, segments.size(), segmentNames);
 
@@ -170,12 +161,7 @@ public String apply(DataSegment input)
       indexingServiceClient.mergeSegments(segments);
     }
     catch (Exception e) {
-      log.error(
-          e,
-          "[%s] Merging error for segments [%s]",
-          dataSource,
-          segmentNames
-      );
+      log.error(e, "[%s] Merging error for segments %s", dataSource, segmentNames);
     }
 
     return segments.size();
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorVersionConverter.java b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorVersionConverter.java
index 5ef69344810d..8072a09e2b5a 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorVersionConverter.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorVersionConverter.java
@@ -57,7 +57,7 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
         final Integer binaryVersion = dataSegment.getBinaryVersion();
 
         if (binaryVersion == null || binaryVersion < IndexIO.CURRENT_VERSION_ID) {
-          log.info("Upgrading version on segment[%s]", dataSegment.getIdentifier());
+          log.info("Upgrading version on segment[%s]", dataSegment.getId());
           indexingServiceClient.upgradeSegment(dataSegment);
         }
       }
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/rules/BroadcastDistributionRule.java b/server/src/main/java/org/apache/druid/server/coordinator/rules/BroadcastDistributionRule.java
index 99f7089a0600..8862b14c20d9 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/rules/BroadcastDistributionRule.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/rules/BroadcastDistributionRule.java
@@ -77,7 +77,7 @@ private CoordinatorStats assign(
     for (ServerHolder holder : serverHolders) {
       if (segment.getSize() > holder.getAvailableSize()) {
         log.makeAlert("Failed to broadcast segment for [%s]", segment.getDataSource())
-           .addData("segmentId", segment.getIdentifier())
+           .addData("segmentId", segment.getId())
            .addData("segmentSize", segment.getSize())
            .addData("hostName", holder.getServer().getHost())
            .addData("availableSize", holder.getAvailableSize())
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/rules/LoadRule.java b/server/src/main/java/org/apache/druid/server/coordinator/rules/LoadRule.java
index e455e939ae97..381a0d97e2db 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/rules/LoadRule.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/rules/LoadRule.java
@@ -32,6 +32,7 @@
 import org.apache.druid.timeline.DataSegment;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import org.apache.druid.timeline.SegmentId;
 
 import javax.annotation.Nullable;
 import java.util.Collections;
@@ -70,7 +71,7 @@ public CoordinatorStats run(
     try {
       // get the "snapshots" of targetReplicants and currentReplicants for assignments.
       targetReplicants.putAll(getTieredReplicants());
-      currentReplicants.putAll(params.getSegmentReplicantLookup().getClusterTiers(segment.getIdentifier()));
+      currentReplicants.putAll(params.getSegmentReplicantLookup().getClusterTiers(segment.getId()));
 
       final CoordinatorStats stats = new CoordinatorStats();
 
@@ -99,7 +100,7 @@ private void assign(
   )
   {
     // if primary replica already exists or is loading
-    final int loading = params.getSegmentReplicantLookup().getTotalReplicants(segment.getIdentifier());
+    final int loading = params.getSegmentReplicantLookup().getTotalReplicants(segment.getId());
     if (!currentReplicants.isEmpty() || loading > 0) {
       assignReplicas(params, segment, stats, null);
     } else {
@@ -178,7 +179,7 @@ private ServerHolder assignPrimary(
       String noAvailability = StringUtils.format(
           "No available [%s] servers or node capacity to assign primary segment[%s]! Expected Replicants[%d]",
           tier,
-          segment.getIdentifier(),
+          segment.getId(),
           targetReplicantsInTier
       );
 
@@ -211,7 +212,7 @@ private ServerHolder assignPrimary(
       strategyCache.remove(topCandidate.getServer().getTier());
       log.info(
           "Assigning 'primary' for segment [%s] to server [%s] in tier [%s]",
-          segment.getIdentifier(),
+          segment.getId(),
           topCandidate.getServer().getName(),
           topCandidate.getServer().getTier()
       );
@@ -242,7 +243,7 @@ private void assignReplicas(
       final int numAssigned = assignReplicasForTier(
           tier,
           entry.getIntValue(),
-          params.getSegmentReplicantLookup().getTotalReplicants(segment.getIdentifier(), tier),
+          params.getSegmentReplicantLookup().getTotalReplicants(segment.getId(), tier),
           params,
           createLoadQueueSizeLimitingPredicate(params),
           segment
@@ -272,7 +273,7 @@ private int assignReplicasForTier(
     String noAvailability = StringUtils.format(
         "No available [%s] servers or node capacity to assign segment[%s]! Expected Replicants[%d]",
         tier,
-        segment.getIdentifier(),
+        segment.getId(),
         targetReplicantsInTier
     );
 
@@ -286,7 +287,7 @@ private int assignReplicasForTier(
     final ReplicationThrottler throttler = params.getReplicationManager();
     for (int numAssigned = 0; numAssigned < numToAssign; numAssigned++) {
       if (!throttler.canCreateReplicant(tier)) {
-        log.info("Throttling replication for segment [%s] in tier [%s]", segment.getIdentifier(), tier);
+        log.info("Throttling replication for segment [%s] in tier [%s]", segment.getId(), tier);
         return numAssigned;
       }
 
@@ -303,16 +304,16 @@ private int assignReplicasForTier(
       }
       holders.remove(holder);
 
-      final String segmentId = segment.getIdentifier();
+      final SegmentId segmentId = segment.getId();
       final String holderHost = holder.getServer().getHost();
       throttler.registerReplicantCreation(tier, segmentId, holderHost);
       log.info(
           "Assigning 'replica' for segment [%s] to server [%s] in tier [%s]",
-          segment.getIdentifier(),
+          segment.getId(),
           holder.getServer().getName(),
           holder.getServer().getTier()
       );
-      holder.getPeon().loadSegment(segment, () -> throttler.unregisterReplicantCreation(tier, segmentId, holderHost));
+      holder.getPeon().loadSegment(segment, () -> throttler.unregisterReplicantCreation(tier, segmentId));
     }
 
     return numToAssign;
@@ -390,7 +391,7 @@ private static int dropForTier(
 
     while (numDropped < numToDrop) {
       if (!iterator.hasNext()) {
-        log.warn("Wtf, holder was null?  I have no servers serving [%s]?", segment.getIdentifier());
+        log.warn("Wtf, holder was null?  I have no servers serving [%s]?", segment.getId());
         break;
       }
 
@@ -399,7 +400,7 @@ private static int dropForTier(
       if (holder.isServingSegment(segment)) {
         log.info(
             "Dropping segment [%s] on server [%s] in tier [%s]",
-            segment.getIdentifier(),
+            segment.getId(),
             holder.getServer().getName(),
             holder.getServer().getTier()
         );
@@ -409,7 +410,7 @@ private static int dropForTier(
         log.warn(
             "Server [%s] is no longer serving segment [%s], skipping drop.",
             holder.getServer().getName(),
-            segment.getIdentifier()
+            segment.getId()
         );
       }
     }
diff --git a/server/src/main/java/org/apache/druid/server/http/CoordinatorResource.java b/server/src/main/java/org/apache/druid/server/http/CoordinatorResource.java
index 167fc6c7d110..6578d74786b1 100644
--- a/server/src/main/java/org/apache/druid/server/http/CoordinatorResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/CoordinatorResource.java
@@ -150,36 +150,12 @@ public Object apply(LoadQueuePeon input)
             new Function<LoadQueuePeon, Object>()
             {
               @Override
-              public Object apply(LoadQueuePeon input)
+              public Object apply(LoadQueuePeon peon)
               {
-                return new ImmutableMap.Builder<>()
-                    .put(
-                        "segmentsToLoad",
-                        Collections2.transform(
-                            input.getSegmentsToLoad(),
-                            new Function<DataSegment, Object>()
-                            {
-                              @Override
-                              public String apply(DataSegment segment)
-                              {
-                                return segment.getIdentifier();
-                              }
-                            }
-                        )
-                    )
-                    .put(
-                        "segmentsToDrop", Collections2.transform(
-                            input.getSegmentsToDrop(),
-                            new Function<DataSegment, Object>()
-                            {
-                              @Override
-                              public String apply(DataSegment segment)
-                              {
-                                return segment.getIdentifier();
-                              }
-                            }
-                        )
-                    )
+                return ImmutableMap
+                    .builder()
+                    .put("segmentsToLoad", Collections2.transform(peon.getSegmentsToLoad(), DataSegment::getId))
+                    .put("segmentsToDrop", Collections2.transform(peon.getSegmentsToDrop(), DataSegment::getId))
                     .build();
               }
             }
diff --git a/server/src/main/java/org/apache/druid/server/http/DatasourcesResource.java b/server/src/main/java/org/apache/druid/server/http/DataSourcesResource.java
similarity index 77%
rename from server/src/main/java/org/apache/druid/server/http/DatasourcesResource.java
rename to server/src/main/java/org/apache/druid/server/http/DataSourcesResource.java
index 2708871bb509..f8d03296eb86 100644
--- a/server/src/main/java/org/apache/druid/server/http/DatasourcesResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/DataSourcesResource.java
@@ -33,6 +33,7 @@
 import org.apache.druid.client.ImmutableSegmentLoadInfo;
 import org.apache.druid.client.SegmentLoadInfo;
 import org.apache.druid.client.indexing.IndexingServiceClient;
+import org.apache.druid.guice.annotations.PublicApi;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.MapUtils;
@@ -46,6 +47,7 @@
 import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.server.security.AuthorizerMapper;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.TimelineLookup;
 import org.apache.druid.timeline.TimelineObjectHolder;
 import org.apache.druid.timeline.partition.PartitionChunk;
@@ -67,6 +69,8 @@
 import javax.ws.rs.core.Response;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.EnumMap;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -74,14 +78,16 @@
 import java.util.Set;
 import java.util.SortedMap;
 import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 /**
  */
 @Path("/druid/coordinator/v1/datasources")
-public class DatasourcesResource
+public class DataSourcesResource
 {
-  private static final Logger log = new Logger(DatasourcesResource.class);
+  private static final Logger log = new Logger(DataSourcesResource.class);
 
   private final CoordinatorServerView serverInventoryView;
   private final MetadataSegmentManager databaseSegmentManager;
@@ -90,7 +96,7 @@ public class DatasourcesResource
   private final AuthorizerMapper authorizerMapper;
 
   @Inject
-  public DatasourcesResource(
+  public DataSourcesResource(
       CoordinatorServerView serverInventoryView,
       MetadataSegmentManager databaseSegmentManager,
       @Nullable IndexingServiceClient indexingServiceClient,
@@ -167,7 +173,7 @@ public Response enableDataSource(
       @PathParam("dataSourceName") final String dataSourceName
   )
   {
-    if (!databaseSegmentManager.enableDatasource(dataSourceName)) {
+    if (!databaseSegmentManager.enableDataSource(dataSourceName)) {
       return Response.noContent().build();
     }
 
@@ -223,7 +229,7 @@ public Response deleteDataSource(
                        .build();
       }
     } else {
-      if (!databaseSegmentManager.removeDatasource(dataSourceName)) {
+      if (!databaseSegmentManager.removeDataSource(dataSourceName)) {
         return Response.noContent().build();
       }
     }
@@ -270,58 +276,17 @@ public Response getSegmentDataSourceIntervals(
       @QueryParam("full") String full
   )
   {
-    final ImmutableDruidDataSource dataSource = getDataSource(dataSourceName);
-
-    if (dataSource == null) {
-      return Response.noContent().build();
-    }
-
-    final Comparator<Interval> comparator = Comparators.inverse(Comparators.intervalsByStartThenEnd());
-
-    if (full != null) {
-      final Map<Interval, Map<String, Object>> retVal = Maps.newTreeMap(comparator);
-      for (DataSegment dataSegment : dataSource.getSegments()) {
-        Map<String, Object> segments = retVal.get(dataSegment.getInterval());
-        if (segments == null) {
-          segments = Maps.newHashMap();
-          retVal.put(dataSegment.getInterval(), segments);
-        }
-
-        Pair<DataSegment, Set<String>> val = getSegment(dataSegment.getIdentifier());
-
-        if (val != null) {
-          segments.put(dataSegment.getIdentifier(), ImmutableMap.of("metadata", val.lhs, "servers", val.rhs));
-        }
-      }
-
-      return Response.ok(retVal).build();
-    }
-
-    if (simple != null) {
-      final Map<Interval, Map<String, Object>> retVal = Maps.newTreeMap(comparator);
-      for (DataSegment dataSegment : dataSource.getSegments()) {
-        Map<String, Object> properties = retVal.get(dataSegment.getInterval());
-        if (properties == null) {
-          properties = Maps.newHashMap();
-          properties.put("size", dataSegment.getSize());
-          properties.put("count", 1);
-
-          retVal.put(dataSegment.getInterval(), properties);
-        } else {
-          properties.put("size", MapUtils.getLong(properties, "size", 0L) + dataSegment.getSize());
-          properties.put("count", MapUtils.getInt(properties, "count", 0) + 1);
-        }
+    if (simple == null && full == null) {
+      final ImmutableDruidDataSource dataSource = getDataSource(dataSourceName);
+      if (dataSource == null) {
+        return Response.noContent().build();
       }
-
-      return Response.ok(retVal).build();
-    }
-
-    final Set<Interval> intervals = Sets.newTreeSet(comparator);
-    for (DataSegment dataSegment : dataSource.getSegments()) {
-      intervals.add(dataSegment.getInterval());
+      final Comparator<Interval> comparator = Comparators.intervalsByStartThenEnd().reversed();
+      Set<Interval> intervals = new TreeSet<>(comparator);
+      dataSource.getSegments().forEach(segment -> intervals.add(segment.getInterval()));
+      return Response.ok(intervals).build();
     }
-
-    return Response.ok(intervals).build();
+    return getSegmentDataSourceIntervals(dataSourceName, full != null, interval -> true);
   }
 
   @GET
@@ -335,64 +300,75 @@ public Response getSegmentDataSourceSpecificInterval(
       @QueryParam("full") String full
   )
   {
-    final ImmutableDruidDataSource dataSource = getDataSource(dataSourceName);
     final Interval theInterval = Intervals.of(interval.replace("_", "/"));
+    if (simple == null && full == null) {
+      final ImmutableDruidDataSource dataSource = getDataSource(dataSourceName);
+      if (dataSource == null) {
+        return Response.noContent().build();
+      }
+      final Set<SegmentId> segmentIds = Sets.newTreeSet();
+      for (DataSegment dataSegment : dataSource.getSegments()) {
+        if (theInterval.contains(dataSegment.getInterval())) {
+          segmentIds.add(dataSegment.getId());
+        }
+      }
+      return Response.ok(segmentIds).build();
+    }
+    return getSegmentDataSourceIntervals(dataSourceName, full != null, theInterval::contains);
+  }
+
+  /**
+   * The property names belong to the public HTTP JSON API.
+   */
+  @PublicApi
+  enum SimpleProperties
+  {
+    size,
+    count
+  }
+
+  private Response getSegmentDataSourceIntervals(
+      String dataSourceName,
+      boolean full,
+      Predicate<Interval> intervalFilter
+  )
+  {
+    final ImmutableDruidDataSource dataSource = getDataSource(dataSourceName);
 
     if (dataSource == null) {
       return Response.noContent().build();
     }
 
-    final Comparator<Interval> comparator = Comparators.inverse(Comparators.intervalsByStartThenEnd());
-    if (full != null) {
-      final Map<Interval, Map<String, Object>> retVal = Maps.newTreeMap(comparator);
+    final Comparator<Interval> comparator = Comparators.intervalsByStartThenEnd().reversed();
+
+    if (full) {
+      final Map<Interval, Map<SegmentId, Object>> retVal = Maps.newTreeMap(comparator);
       for (DataSegment dataSegment : dataSource.getSegments()) {
-        if (theInterval.contains(dataSegment.getInterval())) {
-          Map<String, Object> segments = retVal.get(dataSegment.getInterval());
-          if (segments == null) {
-            segments = Maps.newHashMap();
-            retVal.put(dataSegment.getInterval(), segments);
-          }
+        if (intervalFilter.test(dataSegment.getInterval())) {
+          Map<SegmentId, Object> segments = retVal.computeIfAbsent(dataSegment.getInterval(), i -> new HashMap<>());
 
-          Pair<DataSegment, Set<String>> val = getSegment(dataSegment.getIdentifier());
+          Pair<DataSegment, Set<String>> val = getServersWhereSegmentIsServed(dataSegment.getId());
 
           if (val != null) {
-            segments.put(dataSegment.getIdentifier(), ImmutableMap.of("metadata", val.lhs, "servers", val.rhs));
+            segments.put(dataSegment.getId(), ImmutableMap.of("metadata", val.lhs, "servers", val.rhs));
           }
         }
       }
 
       return Response.ok(retVal).build();
-    }
-
-    if (simple != null) {
-      final Map<Interval, Map<String, Object>> retVal = Maps.newHashMap();
+    } else {
+      final Map<Interval, Map<SimpleProperties, Object>> retVal = Maps.newTreeMap(comparator);
       for (DataSegment dataSegment : dataSource.getSegments()) {
-        if (theInterval.contains(dataSegment.getInterval())) {
-          Map<String, Object> properties = retVal.get(dataSegment.getInterval());
-          if (properties == null) {
-            properties = Maps.newHashMap();
-            properties.put("size", dataSegment.getSize());
-            properties.put("count", 1);
-
-            retVal.put(dataSegment.getInterval(), properties);
-          } else {
-            properties.put("size", MapUtils.getLong(properties, "size", 0L) + dataSegment.getSize());
-            properties.put("count", MapUtils.getInt(properties, "count", 0) + 1);
-          }
+        if (intervalFilter.test(dataSegment.getInterval())) {
+          Map<SimpleProperties, Object> properties =
+              retVal.computeIfAbsent(dataSegment.getInterval(), i -> new EnumMap<>(SimpleProperties.class));
+          properties.merge(SimpleProperties.size, dataSegment.getSize(), (a, b) -> (Long) a + (Long) b);
+          properties.merge(SimpleProperties.count, 1, (a, b) -> (Integer) a + (Integer) b);
         }
       }
 
       return Response.ok(retVal).build();
     }
-
-    final Set<String> retVal = Sets.newTreeSet(Comparators.inverse(String.CASE_INSENSITIVE_ORDER));
-    for (DataSegment dataSegment : dataSource.getSegments()) {
-      if (theInterval.contains(dataSegment.getInterval())) {
-        retVal.add(dataSegment.getIdentifier());
-      }
-    }
-
-    return Response.ok(retVal).build();
   }
 
   @GET
@@ -414,12 +390,7 @@ public Response getSegmentDataSourceSegments(
       return builder.entity(dataSource.getSegments()).build();
     }
 
-    return builder.entity(
-        Iterables.transform(
-            dataSource.getSegments(),
-            (DataSegment segment) -> segment.getIdentifier()
-        )
-    ).build();
+    return builder.entity(Iterables.transform(dataSource.getSegments(), DataSegment::getId)).build();
   }
 
   @GET
@@ -436,14 +407,12 @@ public Response getSegmentDataSourceSegment(
       return Response.noContent().build();
     }
 
-    Pair<DataSegment, Set<String>> retVal = getSegment(segmentId);
-
-    if (retVal != null) {
-      return Response.ok(
-          ImmutableMap.of("metadata", retVal.lhs, "servers", retVal.rhs)
-      ).build();
+    for (SegmentId possibleSegmentId : SegmentId.iteratePossibleParsingsWithDataSource(dataSourceName, segmentId)) {
+      Pair<DataSegment, Set<String>> retVal = getServersWhereSegmentIsServed(possibleSegmentId);
+      if (retVal != null) {
+        return Response.ok(ImmutableMap.of("metadata", retVal.lhs, "servers", retVal.rhs)).build();
+      }
     }
-
     return Response.noContent().build();
   }
 
@@ -455,11 +424,10 @@ public Response deleteDatasourceSegment(
       @PathParam("segmentId") String segmentId
   )
   {
-    if (!databaseSegmentManager.removeSegment(dataSourceName, segmentId)) {
-      return Response.noContent().build();
+    if (databaseSegmentManager.removeSegment(dataSourceName, segmentId)) {
+      return Response.ok().build();
     }
-
-    return Response.ok().build();
+    return Response.noContent().build();
   }
 
   @POST
@@ -482,9 +450,7 @@ public Response enableDatasourceSegment(
   @Path("/{dataSourceName}/tiers")
   @Produces(MediaType.APPLICATION_JSON)
   @ResourceFilters(DatasourceResourceFilter.class)
-  public Response getSegmentDataSourceTiers(
-      @PathParam("dataSourceName") String dataSourceName
-  )
+  public Response getSegmentDataSourceTiers(@PathParam("dataSourceName") String dataSourceName)
   {
     Set<String> retVal = Sets.newHashSet();
     for (DruidServer druidServer : serverInventoryView.getInventory()) {
@@ -511,23 +477,24 @@ private ImmutableDruidDataSource getDataSource(final String dataSourceName)
       return null;
     }
 
-    final SortedMap<String, DataSegment> segmentMap = new TreeMap<>();
+    final SortedMap<SegmentId, DataSegment> segmentMap = new TreeMap<>();
     for (ImmutableDruidDataSource dataSource : dataSources) {
       Iterable<DataSegment> segments = dataSource.getSegments();
       for (DataSegment segment : segments) {
-        segmentMap.put(segment.getIdentifier(), segment);
+        segmentMap.put(segment.getId(), segment);
       }
     }
 
     return new ImmutableDruidDataSource(dataSourceName, Collections.emptyMap(), segmentMap);
   }
 
-  private Pair<DataSegment, Set<String>> getSegment(String segmentId)
+  @Nullable
+  private Pair<DataSegment, Set<String>> getServersWhereSegmentIsServed(SegmentId segmentId)
   {
     DataSegment theSegment = null;
     Set<String> servers = Sets.newHashSet();
     for (DruidServer druidServer : serverInventoryView.getInventory()) {
-      DataSegment currSegment = druidServer.getSegments().get(segmentId);
+      DataSegment currSegment = druidServer.getSegment(segmentId);
       if (currSegment != null) {
         theSegment = currSegment;
         servers.add(druidServer.getHost());
@@ -557,7 +524,7 @@ private Map<String, Map<String, Object>> getSimpleDatasource(String dataSourceNa
         "tiers", tiers,
         "segments", segments
     );
-    Set<String> totalDistinctSegments = Sets.newHashSet();
+    Set<SegmentId> totalDistinctSegments = Sets.newHashSet();
     Map<String, HashSet<Object>> tierDistinctSegments = Maps.newHashMap();
 
     long totalSegmentSize = 0;
@@ -579,14 +546,13 @@ private Map<String, Map<String, Object>> getSimpleDatasource(String dataSourceNa
       long dataSourceSegmentSize = 0;
       for (DataSegment dataSegment : druidDataSource.getSegments()) {
         // tier segments stats
-        if (!tierDistinctSegments.get(tier).contains(dataSegment.getIdentifier())) {
+        if (!tierDistinctSegments.get(tier).contains(dataSegment.getId())) {
           dataSourceSegmentSize += dataSegment.getSize();
-          tierDistinctSegments.get(tier).add(dataSegment.getIdentifier());
+          tierDistinctSegments.get(tier).add(dataSegment.getId());
         }
         // total segments stats
-        if (!totalDistinctSegments.contains(dataSegment.getIdentifier())) {
+        if (totalDistinctSegments.add(dataSegment.getId())) {
           totalSegmentSize += dataSegment.getSize();
-          totalDistinctSegments.add(dataSegment.getIdentifier());
 
           minTime = DateTimes.min(minTime, dataSegment.getInterval().getStart());
           maxTime = DateTimes.max(maxTime, dataSegment.getInterval().getEnd());
diff --git a/server/src/main/java/org/apache/druid/server/http/InventoryViewUtils.java b/server/src/main/java/org/apache/druid/server/http/InventoryViewUtils.java
index 06c9bdfe00dc..2c0f13b7989f 100644
--- a/server/src/main/java/org/apache/druid/server/http/InventoryViewUtils.java
+++ b/server/src/main/java/org/apache/druid/server/http/InventoryViewUtils.java
@@ -31,6 +31,7 @@
 import java.util.Comparator;
 import java.util.SortedSet;
 import java.util.TreeSet;
+import java.util.stream.Collectors;
 
 public interface InventoryViewUtils
 {
@@ -45,11 +46,7 @@ static SortedSet<ImmutableDruidDataSource> getDataSources(InventoryView serverIn
                               .stream()
                               .flatMap(server -> server.getDataSources().stream())
                               .map(DruidDataSource::toImmutableDruidDataSource)
-                              .collect(
-                                  () -> new TreeSet<>(comparingByName()),
-                                  TreeSet::add,
-                                  TreeSet::addAll
-                              );
+                              .collect(Collectors.toCollection(() -> new TreeSet<>(comparingByName())));
   }
 
   static SortedSet<ImmutableDruidDataSource> getSecuredDataSources(
diff --git a/server/src/main/java/org/apache/druid/server/http/MetadataResource.java b/server/src/main/java/org/apache/druid/server/http/MetadataResource.java
index 719a290ead68..5df6c109ba96 100644
--- a/server/src/main/java/org/apache/druid/server/http/MetadataResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/MetadataResource.java
@@ -34,6 +34,7 @@
 import org.apache.druid.server.security.AuthorizerMapper;
 import org.apache.druid.server.security.ResourceAction;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 import javax.servlet.http.HttpServletRequest;
@@ -84,10 +85,10 @@ public Response getDatabaseDataSources(
       @Context final HttpServletRequest req
   )
   {
-    final Collection<ImmutableDruidDataSource> druidDataSources = metadataSegmentManager.getInventory();
+    final Collection<ImmutableDruidDataSource> druidDataSources = metadataSegmentManager.getDataSources();
     final Set<String> dataSourceNamesPreAuth;
     if (includeDisabled != null) {
-      dataSourceNamesPreAuth = Sets.newTreeSet(metadataSegmentManager.getAllDatasourceNames());
+      dataSourceNamesPreAuth = Sets.newTreeSet(metadataSegmentManager.getAllDataSourceNames());
     } else {
       dataSourceNamesPreAuth = Sets.newTreeSet(
           Iterables.transform(druidDataSources, ImmutableDruidDataSource::getName)
@@ -128,7 +129,7 @@ public Response getDatabaseSegmentDataSource(
       @PathParam("dataSourceName") final String dataSourceName
   )
   {
-    ImmutableDruidDataSource dataSource = metadataSegmentManager.getInventoryValue(dataSourceName);
+    ImmutableDruidDataSource dataSource = metadataSegmentManager.getDataSource(dataSourceName);
     if (dataSource == null) {
       return Response.status(Response.Status.NOT_FOUND).build();
     }
@@ -145,7 +146,7 @@ public Response getDatabaseSegmentDataSourceSegments(
       @QueryParam("full") String full
   )
   {
-    ImmutableDruidDataSource dataSource = metadataSegmentManager.getInventoryValue(dataSourceName);
+    ImmutableDruidDataSource dataSource = metadataSegmentManager.getDataSource(dataSourceName);
     if (dataSource == null) {
       return Response.status(Response.Status.NOT_FOUND).build();
     }
@@ -155,19 +156,7 @@ public Response getDatabaseSegmentDataSourceSegments(
       return builder.entity(dataSource.getSegments()).build();
     }
 
-    return builder.entity(
-        Iterables.transform(
-            dataSource.getSegments(),
-            new Function<DataSegment, String>()
-            {
-              @Override
-              public String apply(DataSegment segment)
-              {
-                return segment.getIdentifier();
-              }
-            }
-        )
-    ).build();
+    return builder.entity(Collections2.transform(dataSource.getSegments(), DataSegment::getId)).build();
   }
 
   @POST
@@ -187,7 +176,7 @@ public Response getDatabaseSegmentDataSourceSegments(
       return builder.entity(segments).build();
     }
 
-    return builder.entity(Iterables.transform(segments, DataSegment::getIdentifier)).build();
+    return builder.entity(Collections2.transform(segments, DataSegment::getId)).build();
   }
 
   @GET
@@ -199,13 +188,14 @@ public Response getDatabaseSegmentDataSourceSegment(
       @PathParam("segmentId") String segmentId
   )
   {
-    ImmutableDruidDataSource dataSource = metadataSegmentManager.getInventoryValue(dataSourceName);
+    ImmutableDruidDataSource dataSource = metadataSegmentManager.getDataSource(dataSourceName);
     if (dataSource == null) {
       return Response.status(Response.Status.NOT_FOUND).build();
     }
 
-    for (DataSegment segment : dataSource.getSegments()) {
-      if (segment.getIdentifier().equalsIgnoreCase(segmentId)) {
+    for (SegmentId possibleSegmentId : SegmentId.iteratePossibleParsingsWithDataSource(dataSourceName, segmentId)) {
+      DataSegment segment = dataSource.getSegment(possibleSegmentId);
+      if (segment != null) {
         return Response.status(Response.Status.OK).entity(segment).build();
       }
     }
diff --git a/server/src/main/java/org/apache/druid/server/http/ServersResource.java b/server/src/main/java/org/apache/druid/server/http/ServersResource.java
index 112d24283ec6..437eb5ae905a 100644
--- a/server/src/main/java/org/apache/druid/server/http/ServersResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/ServersResource.java
@@ -19,17 +19,17 @@
 
 package org.apache.druid.server.http;
 
-import com.google.common.base.Function;
 import com.google.common.collect.Collections2;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
+import com.google.common.collect.Iterators;
 import com.google.inject.Inject;
 import com.sun.jersey.spi.container.ResourceFilters;
 import org.apache.druid.client.DruidServer;
 import org.apache.druid.client.InventoryView;
 import org.apache.druid.server.http.security.StateResourceFilter;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 import javax.ws.rs.GET;
 import javax.ws.rs.Path;
@@ -38,7 +38,11 @@
 import javax.ws.rs.QueryParam;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Iterator;
 import java.util.Map;
+import java.util.Set;
 
 /**
  */
@@ -58,19 +62,55 @@ private static Map<String, Object> makeSimpleServer(DruidServer input)
         .build();
   }
 
-  private static Map<String, Object> makeFullServer(DruidServer input)
+  private static Map<String, Object> makeFullServer(DruidServer server)
   {
     return new ImmutableMap.Builder<String, Object>()
-        .put("host", input.getHost())
-        .put("maxSize", input.getMaxSize())
-        .put("type", input.getType().toString())
-        .put("tier", input.getTier())
-        .put("priority", input.getPriority())
-        .put("segments", input.getSegments())
-        .put("currSize", input.getCurrSize())
+        .put("host", server.getHost())
+        .put("maxSize", server.getMaxSize())
+        .put("type", server.getType().toString())
+        .put("tier", server.getTier())
+        .put("priority", server.getPriority())
+        .put("segments", createLazySegmentsMap(server))
+        .put("currSize", server.getCurrSize())
         .build();
   }
 
+  /**
+   * Emitting this map with "full" options in this resource is excessive because segment ids are repeated in the keys
+   * *and* values, but is done so for compatibility with the existing HTTP JSON API.
+   *
+   * Returns a lazy map suitable for serialization (i. e. entrySet iteration) only, relying on the fact that the
+   * segments returned from {@link DruidServer#getSegments()} are unique. This is not a part of the {@link DruidServer}
+   * API to not let abuse this map (like trying to get() from it).
+   */
+  private static Map<SegmentId, DataSegment> createLazySegmentsMap(DruidServer server)
+  {
+    return new AbstractMap<SegmentId, DataSegment>()
+    {
+      @Override
+      public Set<Entry<SegmentId, DataSegment>> entrySet()
+      {
+        return new AbstractSet<Entry<SegmentId, DataSegment>>()
+        {
+          @Override
+          public Iterator<Entry<SegmentId, DataSegment>> iterator()
+          {
+            return Iterators.transform(
+                server.getSegments().iterator(),
+                segment -> new AbstractMap.SimpleImmutableEntry<>(segment.getId(), segment)
+            );
+          }
+
+          @Override
+          public int size()
+          {
+            return server.getTotalSegments();
+          }
+        };
+      }
+    };
+  }
+
   private final InventoryView serverInventoryView;
 
   @Inject
@@ -83,71 +123,29 @@ public ServersResource(
 
   @GET
   @Produces(MediaType.APPLICATION_JSON)
-  public Response getClusterServers(
-      @QueryParam("full") String full,
-      @QueryParam("simple") String simple
-  )
+  public Response getClusterServers(@QueryParam("full") String full, @QueryParam("simple") String simple)
   {
     Response.ResponseBuilder builder = Response.status(Response.Status.OK);
 
     if (full != null) {
-      return builder.entity(
-          Lists.newArrayList(
-              Iterables.transform(
-                  serverInventoryView.getInventory(),
-                  new Function<DruidServer, Map<String, Object>>()
-                  {
-                    @Override
-                    public Map<String, Object> apply(DruidServer input)
-                    {
-                      return makeFullServer(input);
-                    }
-                  }
-              )
-          )
-      ).build();
+      return builder
+          .entity(Collections2.transform(serverInventoryView.getInventory(), ServersResource::makeFullServer))
+          .build();
     } else if (simple != null) {
-      return builder.entity(
-          Lists.newArrayList(
-              Iterables.transform(
-                  serverInventoryView.getInventory(),
-                  new Function<DruidServer, Map<String, Object>>()
-                  {
-                    @Override
-                    public Map<String, Object> apply(DruidServer input)
-                    {
-                      return makeSimpleServer(input);
-                    }
-                  }
-              )
-          )
-      ).build();
+      return builder
+          .entity(Collections2.transform(serverInventoryView.getInventory(), ServersResource::makeSimpleServer))
+          .build();
     }
 
-    return builder.entity(
-        Lists.newArrayList(
-            Iterables.transform(
-                serverInventoryView.getInventory(),
-                new Function<DruidServer, String>()
-                {
-                  @Override
-                  public String apply(DruidServer druidServer)
-                  {
-                    return druidServer.getHost();
-                  }
-                }
-            )
-        )
-    ).build();
+    return builder
+        .entity(Collections2.transform(serverInventoryView.getInventory(), DruidServer::getHost))
+        .build();
   }
 
   @GET
   @Path("/{serverName}")
   @Produces(MediaType.APPLICATION_JSON)
-  public Response getServer(
-      @PathParam("serverName") String serverName,
-      @QueryParam("simple") String simple
-  )
+  public Response getServer(@PathParam("serverName") String serverName, @QueryParam("simple") String simple)
   {
     DruidServer server = serverInventoryView.getInventoryValue(serverName);
     if (server == null) {
@@ -160,17 +158,13 @@ public Response getServer(
       return builder.entity(makeSimpleServer(server)).build();
     }
 
-    return builder.entity(makeFullServer(server))
-                  .build();
+    return builder.entity(makeFullServer(server)).build();
   }
 
   @GET
   @Path("/{serverName}/segments")
   @Produces(MediaType.APPLICATION_JSON)
-  public Response getServerSegments(
-      @PathParam("serverName") String serverName,
-      @QueryParam("full") String full
-  )
+  public Response getServerSegments(@PathParam("serverName") String serverName, @QueryParam("full") String full)
   {
     Response.ResponseBuilder builder = Response.status(Response.Status.OK);
     DruidServer server = serverInventoryView.getInventoryValue(serverName);
@@ -179,42 +173,31 @@ public Response getServerSegments(
     }
 
     if (full != null) {
-      return builder.entity(server.getSegments().values()).build();
+      return builder.entity(Iterables.toString(server.getSegments())).build();
     }
 
-    return builder.entity(
-        Collections2.transform(
-            server.getSegments().values(),
-            new Function<DataSegment, String>()
-            {
-              @Override
-              public String apply(DataSegment segment)
-              {
-                return segment.getIdentifier();
-              }
-            }
-        )
-    ).build();
+    return builder
+        .entity(Iterables.toString(Iterables.transform(server.getSegments(), DataSegment::getId)))
+        .build();
   }
 
   @GET
   @Path("/{serverName}/segments/{segmentId}")
   @Produces(MediaType.APPLICATION_JSON)
-  public Response getServerSegment(
-      @PathParam("serverName") String serverName,
-      @PathParam("segmentId") String segmentId
-  )
+  public Response getServerSegment(@PathParam("serverName") String serverName, @PathParam("segmentId") String segmentId)
   {
     DruidServer server = serverInventoryView.getInventoryValue(serverName);
     if (server == null) {
       return Response.status(Response.Status.NOT_FOUND).build();
     }
 
-    DataSegment segment = server.getSegment(segmentId);
-    if (segment == null) {
-      return Response.status(Response.Status.NOT_FOUND).build();
+    for (SegmentId possibleSegmentId : SegmentId.iterateAllPossibleParsings(segmentId)) {
+      DataSegment segment = server.getSegment(possibleSegmentId);
+      if (segment != null) {
+        return Response.status(Response.Status.OK).entity(segment).build();
+      }
     }
 
-    return Response.status(Response.Status.OK).entity(segment).build();
+    return Response.status(Response.Status.NOT_FOUND).build();
   }
 }
diff --git a/server/src/main/java/org/apache/druid/server/http/TiersResource.java b/server/src/main/java/org/apache/druid/server/http/TiersResource.java
index a3722e805c47..84b22d473289 100644
--- a/server/src/main/java/org/apache/druid/server/http/TiersResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/TiersResource.java
@@ -19,19 +19,12 @@
 
 package org.apache.druid.server.http;
 
-import com.google.common.base.Function;
-import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import com.google.common.collect.Table;
 import com.google.inject.Inject;
 import com.sun.jersey.spi.container.ResourceFilters;
 import org.apache.druid.client.DruidDataSource;
 import org.apache.druid.client.DruidServer;
 import org.apache.druid.client.InventoryView;
-import org.apache.druid.java.util.common.MapUtils;
 import org.apache.druid.server.http.security.StateResourceFilter;
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Interval;
@@ -43,8 +36,11 @@
 import javax.ws.rs.QueryParam;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
+import java.util.EnumMap;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  */
@@ -55,95 +51,79 @@ public class TiersResource
   private final InventoryView serverInventoryView;
 
   @Inject
-  public TiersResource(
-      InventoryView serverInventoryView
-  )
+  public TiersResource(InventoryView serverInventoryView)
   {
     this.serverInventoryView = serverInventoryView;
   }
 
+  private enum TierMetadataKeys
+  {
+    /** Lowercase on purpose, to match the established format. */
+    currSize,
+    maxSize
+  }
+
   @GET
   @Produces(MediaType.APPLICATION_JSON)
-  public Response getTiers(
-      @QueryParam("simple") String simple
-  )
+  public Response getTiers(@QueryParam("simple") String simple)
   {
     Response.ResponseBuilder builder = Response.status(Response.Status.OK);
 
     if (simple != null) {
-      Map<String, Map<String, Long>> metadata = Maps.newHashMap();
+      Map<String, Map<TierMetadataKeys, Long>> metadata = Maps.newHashMap();
       for (DruidServer druidServer : serverInventoryView.getInventory()) {
-        Map<String, Long> tierMetadata = metadata.get(druidServer.getTier());
-
-        if (tierMetadata == null) {
-          tierMetadata = Maps.newHashMap();
-          metadata.put(druidServer.getTier(), tierMetadata);
-        }
-
-        Long currSize = tierMetadata.get("currSize");
-        tierMetadata.put("currSize", ((currSize == null) ? 0 : currSize) + druidServer.getCurrSize());
-
-        Long maxSize = tierMetadata.get("maxSize");
-        tierMetadata.put("maxSize", ((maxSize == null) ? 0 : maxSize) + druidServer.getMaxSize());
+        Map<TierMetadataKeys, Long> tierMetadata = metadata
+            .computeIfAbsent(druidServer.getTier(), tier -> new EnumMap<>(TierMetadataKeys.class));
+        tierMetadata.merge(TierMetadataKeys.currSize, druidServer.getCurrSize(), Long::sum);
+        tierMetadata.merge(TierMetadataKeys.maxSize, druidServer.getMaxSize(), Long::sum);
       }
       return builder.entity(metadata).build();
     }
 
-    Set<String> tiers = Sets.newHashSet();
-    for (DruidServer server : serverInventoryView.getInventory()) {
-      tiers.add(server.getTier());
-    }
+    Set<String> tiers = serverInventoryView
+        .getInventory()
+        .stream()
+        .map(DruidServer::getTier)
+        .collect(Collectors.toSet());
 
     return builder.entity(tiers).build();
   }
 
+  private enum IntervalProperties
+  {
+    /** Lowercase on purpose, to match the established format. */
+    size,
+    count
+  }
+
   @GET
   @Path("/{tierName}")
   @Produces(MediaType.APPLICATION_JSON)
-  public Response getTierDatasources(
-      @PathParam("tierName") String tierName,
-      @QueryParam("simple") String simple
-  )
+  public Response getTierDataSources(@PathParam("tierName") String tierName, @QueryParam("simple") String simple)
   {
     if (simple != null) {
-      Table<String, Interval, Map<String, Object>> retVal = HashBasedTable.create();
+      Map<String, Map<Interval, Map<IntervalProperties, Object>>> retVal = new HashMap<>();
       for (DruidServer druidServer : serverInventoryView.getInventory()) {
         if (druidServer.getTier().equalsIgnoreCase(tierName)) {
-          for (DataSegment dataSegment : druidServer.getSegments().values()) {
-            Map<String, Object> properties = retVal.get(dataSegment.getDataSource(), dataSegment.getInterval());
-            if (properties == null) {
-              properties = Maps.newHashMap();
-              retVal.put(dataSegment.getDataSource(), dataSegment.getInterval(), properties);
-            }
-            properties.put("size", MapUtils.getLong(properties, "size", 0L) + dataSegment.getSize());
-            properties.put("count", MapUtils.getInt(properties, "count", 0) + 1);
+          for (DataSegment dataSegment : druidServer.getSegments()) {
+            Map<IntervalProperties, Object> properties = retVal
+                .computeIfAbsent(dataSegment.getDataSource(), dsName -> new HashMap<>())
+                .computeIfAbsent(dataSegment.getInterval(), interval -> new EnumMap<>(IntervalProperties.class));
+            properties.merge(IntervalProperties.size, dataSegment.getSize(), (a, b) -> (Long) a + (Long) b);
+            properties.merge(IntervalProperties.count, 1, (a, b) -> (Integer) a + (Integer) b);
           }
         }
       }
 
-      return Response.ok(retVal.rowMap()).build();
+      return Response.ok(retVal).build();
     }
 
-    Set<String> retVal = Sets.newHashSet();
-    for (DruidServer druidServer : serverInventoryView.getInventory()) {
-      if (druidServer.getTier().equalsIgnoreCase(tierName)) {
-        retVal.addAll(
-            Lists.newArrayList(
-                Iterables.transform(
-                    druidServer.getDataSources(),
-                    new Function<DruidDataSource, String>()
-                    {
-                      @Override
-                      public String apply(DruidDataSource input)
-                      {
-                        return input.getName();
-                      }
-                    }
-                )
-            )
-        );
-      }
-    }
+    Set<String> retVal = serverInventoryView
+        .getInventory()
+        .stream()
+        .filter(druidServer -> druidServer.getTier().equalsIgnoreCase(tierName))
+        .flatMap(druidServer -> druidServer.getDataSources().stream().map(DruidDataSource::getName))
+        .collect(Collectors.toSet());
 
     return Response.ok(retVal).build();
   }
diff --git a/server/src/main/java/org/apache/druid/timeline/partition/HashBasedNumberedShardSpec.java b/server/src/main/java/org/apache/druid/timeline/partition/HashBasedNumberedShardSpec.java
index 456da4b8c94a..9c6a58c47a03 100644
--- a/server/src/main/java/org/apache/druid/timeline/partition/HashBasedNumberedShardSpec.java
+++ b/server/src/main/java/org/apache/druid/timeline/partition/HashBasedNumberedShardSpec.java
@@ -25,6 +25,7 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
@@ -81,15 +82,13 @@ protected int hash(long timestamp, InputRow inputRow)
     }
   }
 
+  @VisibleForTesting
   List<Object> getGroupKey(final long timestamp, final InputRow inputRow)
   {
     if (partitionDimensions.isEmpty()) {
       return Rows.toGroupKey(timestamp, inputRow);
     } else {
-      return Lists.transform(
-          partitionDimensions,
-          dim -> inputRow.getDimension(dim)
-      );
+      return Lists.transform(partitionDimensions, inputRow::getDimension);
     }
   }
 
diff --git a/server/src/main/java/org/apache/druid/timeline/partition/LinearShardSpec.java b/server/src/main/java/org/apache/druid/timeline/partition/LinearShardSpec.java
index 9e7b68915c54..d0e60c2c5175 100644
--- a/server/src/main/java/org/apache/druid/timeline/partition/LinearShardSpec.java
+++ b/server/src/main/java/org/apache/druid/timeline/partition/LinearShardSpec.java
@@ -32,14 +32,12 @@
 /**
  * An extendable linear shard spec.  {@link #partitionNum} represents an unique id of a partition.
  */
-public class LinearShardSpec implements ShardSpec
+public final class LinearShardSpec implements ShardSpec
 {
-  private int partitionNum;
+  private final int partitionNum;
 
   @JsonCreator
-  public LinearShardSpec(
-      @JsonProperty("partitionNum") Integer partitionNum
-  )
+  public LinearShardSpec(@JsonProperty("partitionNum") Integer partitionNum)
   {
     this.partitionNum = Preconditions.checkNotNull(partitionNum, "Must set partitionNum on LinearShardSpec");
   }
@@ -72,7 +70,7 @@ public boolean possibleInDomain(Map<String, RangeSet<String>> domain)
   @Override
   public <T> PartitionChunk<T> createChunk(T obj)
   {
-    return new LinearPartitionChunk<T>(partitionNum, obj);
+    return new LinearPartitionChunk<>(partitionNum, obj);
   }
 
   @Override
@@ -81,6 +79,25 @@ public boolean isInChunk(long timestamp, InputRow inputRow)
     return true;
   }
 
+  @Override
+  public boolean equals(Object o)
+  {
+    if (this == o) {
+      return true;
+    }
+    if (!(o instanceof LinearShardSpec)) {
+      return false;
+    }
+    LinearShardSpec that = (LinearShardSpec) o;
+    return partitionNum == that.partitionNum;
+  }
+
+  @Override
+  public int hashCode()
+  {
+    return partitionNum;
+  }
+
   @Override
   public String toString()
   {
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
index 83b4aeebcd57..4dbbd8d6d86a 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
@@ -128,6 +128,7 @@
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.apache.druid.timeline.partition.ShardSpec;
@@ -563,7 +564,7 @@ public void testCachingOverBulkLimitEnforcesLimit()
     client = makeClient(new ForegroundCachePopulator(JSON_MAPPER, new CachePopulatorStats(), -1), cache, limit);
     final DruidServer lastServer = servers[random.nextInt(servers.length)];
     final DataSegment dataSegment = EasyMock.createNiceMock(DataSegment.class);
-    EasyMock.expect(dataSegment.getIdentifier()).andReturn(DATA_SOURCE).anyTimes();
+    EasyMock.expect(dataSegment.getId()).andReturn(SegmentId.dummy(DATA_SOURCE)).anyTimes();
     EasyMock.replay(dataSegment);
     final ServerSelector selector = new ServerSelector(
         dataSegment,
@@ -606,9 +607,8 @@ public void testTimeseriesMergingOutOfOrderPartitions()
                                                         .context(CONTEXT);
 
     QueryRunner runner = new FinalizeResultsQueryRunner(
-        getDefaultQueryRunner(), new TimeseriesQueryQueryToolChest(
-        QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator()
-    )
+        getDefaultQueryRunner(),
+        new TimeseriesQueryQueryToolChest(QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator())
     );
 
     testQueryCaching(
@@ -713,9 +713,8 @@ public void testDisableUseCache()
                                                         .postAggregators(POST_AGGS)
                                                         .context(CONTEXT);
     QueryRunner runner = new FinalizeResultsQueryRunner(
-        getDefaultQueryRunner(), new TimeseriesQueryQueryToolChest(
-        QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator()
-    )
+        getDefaultQueryRunner(),
+        new TimeseriesQueryQueryToolChest(QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator())
     );
     testQueryCaching(
         runner,
@@ -865,10 +864,11 @@ public void testTopNCachingTimeZone()
         .context(CONTEXT);
 
     QueryRunner runner = new FinalizeResultsQueryRunner(
-        getDefaultQueryRunner(), new TopNQueryQueryToolChest(
-        new TopNQueryConfig(),
-        QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator()
-    )
+        getDefaultQueryRunner(),
+        new TopNQueryQueryToolChest(
+            new TopNQueryConfig(),
+            QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator()
+        )
     );
 
     testQueryCaching(
@@ -1743,7 +1743,7 @@ private ServerSelector makeMockSingleDimensionSelector(
       DruidServer server, String dimension, String start, String end, int partitionNum)
   {
     DataSegment segment = EasyMock.createNiceMock(DataSegment.class);
-    EasyMock.expect(segment.getIdentifier()).andReturn(DATA_SOURCE).anyTimes();
+    EasyMock.expect(segment.getId()).andReturn(SegmentId.dummy(DATA_SOURCE)).anyTimes();
     EasyMock.expect(segment.getShardSpec()).andReturn(new SingleDimensionShardSpec(dimension, start, end, partitionNum))
             .anyTimes();
     EasyMock.replay(segment);
@@ -1858,7 +1858,7 @@ public void testQueryCachingWithFilter(
         QueryRunner queryable = expectations.getQueryRunner();
 
         if (query instanceof TimeseriesQuery) {
-          final List<String> segmentIds = Lists.newArrayList();
+          final List<SegmentId> segmentIds = Lists.newArrayList();
           final List<Iterable<Result<TimeseriesResultValue>>> results = Lists.newArrayList();
           for (ServerExpectation expectation : expectations) {
             segmentIds.add(expectation.getSegmentId());
@@ -1920,7 +1920,7 @@ public void run()
 
   private Sequence<Result<TimeseriesResultValue>> toFilteredQueryableTimeseriesResults(
       TimeseriesQuery query,
-      List<String> segmentIds,
+      List<SegmentId> segmentIds,
       List<Interval> queryIntervals,
       List<Iterable<Result<TimeseriesResultValue>>> results
   )
@@ -1928,17 +1928,20 @@ private Sequence<Result<TimeseriesResultValue>> toFilteredQueryableTimeseriesRes
     MultipleSpecificSegmentSpec spec = (MultipleSpecificSegmentSpec) query.getQuerySegmentSpec();
     List<Result<TimeseriesResultValue>> ret = Lists.newArrayList();
     for (SegmentDescriptor descriptor : spec.getDescriptors()) {
-      String id = StringUtils.format("%s_%s", queryIntervals.indexOf(descriptor.getInterval()), descriptor.getPartitionNumber());
+      SegmentId id = SegmentId.dummy(
+          StringUtils.format("%s_%s", queryIntervals.indexOf(descriptor.getInterval()), descriptor.getPartitionNumber())
+      );
       int index = segmentIds.indexOf(id);
       if (index != -1) {
-        ret.add(new Result(
+        Result result = new Result(
             results.get(index).iterator().next().getTimestamp(),
             new BySegmentResultValueClass(
                 Lists.newArrayList(results.get(index)),
-                id,
+                id.toString(),
                 descriptor.getInterval()
             )
-        ));
+        );
+        ret.add(result);
       } else {
         throw new ISE("Descriptor %s not found in server", id);
       }
@@ -2000,7 +2003,7 @@ public void testQueryCaching(
         QueryRunner queryable = expectations.getQueryRunner();
 
         if (query instanceof TimeseriesQuery) {
-          List<String> segmentIds = Lists.newArrayList();
+          List<SegmentId> segmentIds = Lists.newArrayList();
           List<Interval> intervals = Lists.newArrayList();
           List<Iterable<Result<TimeseriesResultValue>>> results = Lists.newArrayList();
           for (ServerExpectation expectation : expectations) {
@@ -2013,7 +2016,7 @@ public void testQueryCaching(
                   .once();
 
         } else if (query instanceof TopNQuery) {
-          List<String> segmentIds = Lists.newArrayList();
+          List<SegmentId> segmentIds = Lists.newArrayList();
           List<Interval> intervals = Lists.newArrayList();
           List<Iterable<Result<TopNResultValue>>> results = Lists.newArrayList();
           for (ServerExpectation expectation : expectations) {
@@ -2025,7 +2028,7 @@ public void testQueryCaching(
                   .andReturn(toQueryableTopNResults(segmentIds, intervals, results))
                   .once();
         } else if (query instanceof SearchQuery) {
-          List<String> segmentIds = Lists.newArrayList();
+          List<SegmentId> segmentIds = Lists.newArrayList();
           List<Interval> intervals = Lists.newArrayList();
           List<Iterable<Result<SearchResultValue>>> results = Lists.newArrayList();
           for (ServerExpectation expectation : expectations) {
@@ -2037,7 +2040,7 @@ public void testQueryCaching(
                   .andReturn(toQueryableSearchResults(segmentIds, intervals, results))
                   .once();
         } else if (query instanceof SelectQuery) {
-          List<String> segmentIds = Lists.newArrayList();
+          List<SegmentId> segmentIds = Lists.newArrayList();
           List<Interval> intervals = Lists.newArrayList();
           List<Iterable<Result<SelectResultValue>>> results = Lists.newArrayList();
           for (ServerExpectation expectation : expectations) {
@@ -2049,7 +2052,7 @@ public void testQueryCaching(
                   .andReturn(toQueryableSelectResults(segmentIds, intervals, results))
                   .once();
         } else if (query instanceof GroupByQuery) {
-          List<String> segmentIds = Lists.newArrayList();
+          List<SegmentId> segmentIds = Lists.newArrayList();
           List<Interval> intervals = Lists.newArrayList();
           List<Iterable<Row>> results = Lists.newArrayList();
           for (ServerExpectation expectation : expectations) {
@@ -2061,7 +2064,7 @@ public void testQueryCaching(
                   .andReturn(toQueryableGroupByResults(segmentIds, intervals, results))
                   .once();
         } else if (query instanceof TimeBoundaryQuery) {
-          List<String> segmentIds = Lists.newArrayList();
+          List<SegmentId> segmentIds = Lists.newArrayList();
           List<Interval> intervals = Lists.newArrayList();
           List<Iterable<Result<TimeBoundaryResultValue>>> results = Lists.newArrayList();
           for (ServerExpectation expectation : expectations) {
@@ -2176,8 +2179,8 @@ private List<Map<DruidServer, ServerExpectations>> populateTimeline(
         }
 
         DataSegment mockSegment = makeMock(mocks, DataSegment.class);
-        ServerExpectation expectation = new ServerExpectation(
-            StringUtils.format("%s_%s", k, j), // interval/chunk
+        ServerExpectation<Object> expectation = new ServerExpectation<>(
+            SegmentId.dummy(StringUtils.format("%s_%s", k, j)), // interval/chunk
             queryIntervals.get(k),
             mockSegment,
             expectedResults.get(k).get(j)
@@ -2215,7 +2218,7 @@ private List<Map<DruidServer, ServerExpectations>> populateTimeline(
 
   private Sequence<Result<TimeseriesResultValue>> toQueryableTimeseriesResults(
       boolean bySegment,
-      Iterable<String> segmentIds,
+      Iterable<SegmentId> segmentIds,
       Iterable<Interval> intervals,
       Iterable<Iterable<Result<TimeseriesResultValue>>> results
   )
@@ -2227,12 +2230,12 @@ private Sequence<Result<TimeseriesResultValue>> toQueryableTimeseriesResults(
               .trinaryTransform(
                   intervals,
                   results,
-                  new TrinaryFn<String, Interval, Iterable<Result<TimeseriesResultValue>>, Result<TimeseriesResultValue>>()
+                  new TrinaryFn<SegmentId, Interval, Iterable<Result<TimeseriesResultValue>>, Result<TimeseriesResultValue>>()
                   {
                     @Override
                     @SuppressWarnings("unchecked")
                     public Result<TimeseriesResultValue> apply(
-                        final String segmentId,
+                        final SegmentId segmentId,
                         final Interval interval,
                         final Iterable<Result<TimeseriesResultValue>> results
                     )
@@ -2241,7 +2244,7 @@ public Result<TimeseriesResultValue> apply(
                           results.iterator().next().getTimestamp(),
                           new BySegmentResultValueClass(
                               Lists.newArrayList(results),
-                              segmentId,
+                              segmentId.toString(),
                               interval
                           )
                       );
@@ -2255,7 +2258,9 @@ public Result<TimeseriesResultValue> apply(
   }
 
   private Sequence<Result<TopNResultValue>> toQueryableTopNResults(
-      Iterable<String> segmentIds, Iterable<Interval> intervals, Iterable<Iterable<Result<TopNResultValue>>> results
+      Iterable<SegmentId> segmentIds,
+      Iterable<Interval> intervals,
+      Iterable<Iterable<Result<TopNResultValue>>> results
   )
   {
     return Sequences.simple(
@@ -2264,12 +2269,12 @@ private Sequence<Result<TopNResultValue>> toQueryableTopNResults(
             .trinaryTransform(
                 intervals,
                 results,
-                new TrinaryFn<String, Interval, Iterable<Result<TopNResultValue>>, Result<TopNResultValue>>()
+                new TrinaryFn<SegmentId, Interval, Iterable<Result<TopNResultValue>>, Result<TopNResultValue>>()
                 {
                   @Override
                   @SuppressWarnings("unchecked")
                   public Result<TopNResultValue> apply(
-                      final String segmentId,
+                      final SegmentId segmentId,
                       final Interval interval,
                       final Iterable<Result<TopNResultValue>> results
                   )
@@ -2278,7 +2283,7 @@ public Result<TopNResultValue> apply(
                         interval.getStart(),
                         new BySegmentResultValueClass(
                             Lists.newArrayList(results),
-                            segmentId,
+                            segmentId.toString(),
                             interval
                         )
                     );
@@ -2289,7 +2294,9 @@ public Result<TopNResultValue> apply(
   }
 
   private Sequence<Result<SearchResultValue>> toQueryableSearchResults(
-      Iterable<String> segmentIds, Iterable<Interval> intervals, Iterable<Iterable<Result<SearchResultValue>>> results
+      Iterable<SegmentId> segmentIds,
+      Iterable<Interval> intervals,
+      Iterable<Iterable<Result<SearchResultValue>>> results
   )
   {
     return Sequences.simple(
@@ -2298,12 +2305,12 @@ private Sequence<Result<SearchResultValue>> toQueryableSearchResults(
             .trinaryTransform(
                 intervals,
                 results,
-                new TrinaryFn<String, Interval, Iterable<Result<SearchResultValue>>, Result<SearchResultValue>>()
+                new TrinaryFn<SegmentId, Interval, Iterable<Result<SearchResultValue>>, Result<SearchResultValue>>()
                 {
                   @Override
                   @SuppressWarnings("unchecked")
                   public Result<SearchResultValue> apply(
-                      final String segmentId,
+                      final SegmentId segmentId,
                       final Interval interval,
                       final Iterable<Result<SearchResultValue>> results
                   )
@@ -2312,7 +2319,7 @@ public Result<SearchResultValue> apply(
                         results.iterator().next().getTimestamp(),
                         new BySegmentResultValueClass(
                             Lists.newArrayList(results),
-                            segmentId,
+                            segmentId.toString(),
                             interval
                         )
                     );
@@ -2323,7 +2330,9 @@ public Result<SearchResultValue> apply(
   }
 
   private Sequence<Result<SelectResultValue>> toQueryableSelectResults(
-      Iterable<String> segmentIds, Iterable<Interval> intervals, Iterable<Iterable<Result<SelectResultValue>>> results
+      Iterable<SegmentId> segmentIds,
+      Iterable<Interval> intervals,
+      Iterable<Iterable<Result<SelectResultValue>>> results
   )
   {
     return Sequences.simple(
@@ -2332,12 +2341,12 @@ private Sequence<Result<SelectResultValue>> toQueryableSelectResults(
             .trinaryTransform(
                 intervals,
                 results,
-                new TrinaryFn<String, Interval, Iterable<Result<SelectResultValue>>, Result<SelectResultValue>>()
+                new TrinaryFn<SegmentId, Interval, Iterable<Result<SelectResultValue>>, Result<SelectResultValue>>()
                 {
                   @Override
                   @SuppressWarnings("unchecked")
                   public Result<SelectResultValue> apply(
-                      final String segmentId,
+                      final SegmentId segmentId,
                       final Interval interval,
                       final Iterable<Result<SelectResultValue>> results
                   )
@@ -2346,7 +2355,7 @@ public Result<SelectResultValue> apply(
                         results.iterator().next().getTimestamp(),
                         new BySegmentResultValueClass(
                             Lists.newArrayList(results),
-                            segmentId,
+                            segmentId.toString(),
                             interval
                         )
                     );
@@ -2357,7 +2366,9 @@ public Result<SelectResultValue> apply(
   }
 
   private Sequence<Result> toQueryableGroupByResults(
-      Iterable<String> segmentIds, Iterable<Interval> intervals, Iterable<Iterable<Row>> results
+      Iterable<SegmentId> segmentIds,
+      Iterable<Interval> intervals,
+      Iterable<Iterable<Row>> results
   )
   {
     return Sequences.simple(
@@ -2366,21 +2377,17 @@ private Sequence<Result> toQueryableGroupByResults(
             .trinaryTransform(
                 intervals,
                 results,
-                new TrinaryFn<String, Interval, Iterable<Row>, Result>()
+                new TrinaryFn<SegmentId, Interval, Iterable<Row>, Result>()
                 {
                   @Override
                   @SuppressWarnings("unchecked")
-                  public Result apply(
-                      final String segmentId,
-                      final Interval interval,
-                      final Iterable<Row> results
-                  )
+                  public Result apply(final SegmentId segmentId, final Interval interval, final Iterable<Row> results)
                   {
                     return new Result(
                         results.iterator().next().getTimestamp(),
                         new BySegmentResultValueClass(
                             Lists.newArrayList(results),
-                            segmentId,
+                            segmentId.toString(),
                             interval
                         )
                     );
@@ -2391,7 +2398,7 @@ public Result apply(
   }
 
   private Sequence<Result<TimeBoundaryResultValue>> toQueryableTimeBoundaryResults(
-      Iterable<String> segmentIds,
+      Iterable<SegmentId> segmentIds,
       Iterable<Interval> intervals,
       Iterable<Iterable<Result<TimeBoundaryResultValue>>> results
   )
@@ -2402,12 +2409,12 @@ private Sequence<Result<TimeBoundaryResultValue>> toQueryableTimeBoundaryResults
             .trinaryTransform(
                 intervals,
                 results,
-                new TrinaryFn<String, Interval, Iterable<Result<TimeBoundaryResultValue>>, Result<TimeBoundaryResultValue>>()
+                new TrinaryFn<SegmentId, Interval, Iterable<Result<TimeBoundaryResultValue>>, Result<TimeBoundaryResultValue>>()
                 {
                   @Override
                   @SuppressWarnings("unchecked")
                   public Result<TimeBoundaryResultValue> apply(
-                      final String segmentId,
+                      final SegmentId segmentId,
                       final Interval interval,
                       final Iterable<Result<TimeBoundaryResultValue>> results
                   )
@@ -2416,7 +2423,7 @@ public Result<TimeBoundaryResultValue> apply(
                         results.iterator().next().getTimestamp(),
                         new BySegmentResultValueClass(
                             Lists.newArrayList(results),
-                            segmentId,
+                            segmentId.toString(),
                             interval
                         )
                     );
@@ -2698,13 +2705,13 @@ public long getMaxQueuedBytes()
 
   private static class ServerExpectation<T>
   {
-    private final String segmentId;
+    private final SegmentId segmentId;
     private final Interval interval;
     private final DataSegment segment;
     private final Iterable<Result<T>> results;
 
     public ServerExpectation(
-        String segmentId,
+        SegmentId segmentId,
         Interval interval,
         DataSegment segment,
         Iterable<Result<T>> results
@@ -2716,7 +2723,7 @@ public ServerExpectation(
       this.results = results;
     }
 
-    public String getSegmentId()
+    public SegmentId getSegmentId()
     {
       return segmentId;
     }
@@ -2819,7 +2826,7 @@ public long getSize()
       }
 
       @Override
-      public String getIdentifier()
+      public SegmentId getId()
       {
         return segmentId;
       }
diff --git a/server/src/test/java/org/apache/druid/client/CachingQueryRunnerTest.java b/server/src/test/java/org/apache/druid/client/CachingQueryRunnerTest.java
index b20edd804a09..122be1bca0e0 100644
--- a/server/src/test/java/org/apache/druid/client/CachingQueryRunnerTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingQueryRunnerTest.java
@@ -270,12 +270,12 @@ public void doMonitor(ServiceEmitter emitter)
       }
     };
 
-    String segmentIdentifier = "segment";
+    String cacheId = "segment";
     SegmentDescriptor segmentDescriptor = new SegmentDescriptor(Intervals.of("2011/2012"), "version", 0);
 
     DefaultObjectMapper objectMapper = new DefaultObjectMapper();
     CachingQueryRunner runner = new CachingQueryRunner(
-        segmentIdentifier,
+        cacheId,
         segmentDescriptor,
         objectMapper,
         cache,
@@ -307,7 +307,7 @@ public boolean isUseCache()
 
     CacheStrategy cacheStrategy = toolchest.getCacheStrategy(query);
     Cache.NamedKey cacheKey = CacheUtil.computeSegmentCacheKey(
-        segmentIdentifier,
+        cacheId,
         segmentDescriptor,
         cacheStrategy.computeCacheKey(query)
     );
@@ -348,12 +348,12 @@ private void testUseCache(
   ) throws IOException
   {
     DefaultObjectMapper objectMapper = new DefaultObjectMapper();
-    String segmentIdentifier = "segment";
+    String cacheId = "segment";
     SegmentDescriptor segmentDescriptor = new SegmentDescriptor(Intervals.of("2011/2012"), "version", 0);
 
     CacheStrategy cacheStrategy = toolchest.getCacheStrategy(query);
     Cache.NamedKey cacheKey = CacheUtil.computeSegmentCacheKey(
-        segmentIdentifier,
+        cacheId,
         segmentDescriptor,
         cacheStrategy.computeCacheKey(query)
     );
@@ -362,7 +362,7 @@ private void testUseCache(
     cache.put(cacheKey, toByteArray(Iterables.transform(expectedResults, cacheStrategy.prepareForSegmentLevelCache())));
 
     CachingQueryRunner runner = new CachingQueryRunner(
-        segmentIdentifier,
+        cacheId,
         segmentDescriptor,
         objectMapper,
         cache,
diff --git a/server/src/test/java/org/apache/druid/client/CoordinatorServerViewTest.java b/server/src/test/java/org/apache/druid/client/CoordinatorServerViewTest.java
index ec67833e504a..dca294757432 100644
--- a/server/src/test/java/org/apache/druid/client/CoordinatorServerViewTest.java
+++ b/server/src/test/java/org/apache/druid/client/CoordinatorServerViewTest.java
@@ -243,12 +243,10 @@ public DataSegment apply(Pair<String, String> input)
 
   private void unannounceSegmentForServer(DruidServer druidServer, DataSegment segment) throws Exception
   {
-    curator.delete().guaranteed().forPath(
-        ZKPaths.makePath(
-            ZKPaths.makePath(inventoryPath, druidServer.getHost()),
-            segment.getIdentifier()
-        )
-    );
+    curator
+        .delete()
+        .guaranteed()
+        .forPath(ZKPaths.makePath(inventoryPath, druidServer.getHost(), segment.getId().toString()));
   }
 
   private Pair<Interval, Pair<String, Pair<DruidServer, DataSegment>>> createExpected(
diff --git a/server/src/test/java/org/apache/druid/client/HttpServerInventoryViewTest.java b/server/src/test/java/org/apache/druid/client/HttpServerInventoryViewTest.java
index fbeae25f769c..9e9238c37110 100644
--- a/server/src/test/java/org/apache/druid/client/HttpServerInventoryViewTest.java
+++ b/server/src/test/java/org/apache/druid/client/HttpServerInventoryViewTest.java
@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
@@ -43,6 +44,7 @@
 import org.apache.druid.server.coordination.ChangeRequestsSnapshot;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.easymock.EasyMock;
 import org.jboss.netty.buffer.ChannelBuffers;
 import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
@@ -184,16 +186,16 @@ DataNodeService.DISCOVERY_SERVICE_KEY, new DataNodeService("tier", 1000, ServerT
 
     CountDownLatch initializeCallback1 = new CountDownLatch(1);
 
-    Map<String, CountDownLatch> segmentAddLathces = ImmutableMap.of(
-        segment1.getIdentifier(), new CountDownLatch(1),
-        segment2.getIdentifier(), new CountDownLatch(1),
-        segment3.getIdentifier(), new CountDownLatch(1),
-        segment4.getIdentifier(), new CountDownLatch(1)
+    Map<SegmentId, CountDownLatch> segmentAddLathces = ImmutableMap.of(
+        segment1.getId(), new CountDownLatch(1),
+        segment2.getId(), new CountDownLatch(1),
+        segment3.getId(), new CountDownLatch(1),
+        segment4.getId(), new CountDownLatch(1)
     );
 
-    Map<String, CountDownLatch> segmentDropLatches = ImmutableMap.of(
-        segment1.getIdentifier(), new CountDownLatch(1),
-        segment2.getIdentifier(), new CountDownLatch(1)
+    Map<SegmentId, CountDownLatch> segmentDropLatches = ImmutableMap.of(
+        segment1.getId(), new CountDownLatch(1),
+        segment2.getId(), new CountDownLatch(1)
     );
 
     httpServerInventoryView.registerSegmentCallback(
@@ -205,7 +207,7 @@ public ServerView.CallbackAction segmentAdded(
               DruidServerMetadata server, DataSegment segment
           )
           {
-            segmentAddLathces.get(segment.getIdentifier()).countDown();
+            segmentAddLathces.get(segment.getId()).countDown();
             return ServerView.CallbackAction.CONTINUE;
           }
 
@@ -214,7 +216,7 @@ public ServerView.CallbackAction segmentRemoved(
               DruidServerMetadata server, DataSegment segment
           )
           {
-            segmentDropLatches.get(segment.getIdentifier()).countDown();
+            segmentDropLatches.get(segment.getId()).countDown();
             return ServerView.CallbackAction.CONTINUE;
           }
 
@@ -250,16 +252,18 @@ public ServerView.CallbackAction serverRemoved(DruidServer server)
     druidNodeDiscovery.listener.nodesAdded(ImmutableList.of(druidNode));
 
     initializeCallback1.await();
-    segmentAddLathces.get(segment1.getIdentifier()).await();
-    segmentDropLatches.get(segment1.getIdentifier()).await();
-    segmentAddLathces.get(segment2.getIdentifier()).await();
-    segmentAddLathces.get(segment3.getIdentifier()).await();
-    segmentAddLathces.get(segment4.getIdentifier()).await();
-    segmentDropLatches.get(segment2.getIdentifier()).await();
+    segmentAddLathces.get(segment1.getId()).await();
+    segmentDropLatches.get(segment1.getId()).await();
+    segmentAddLathces.get(segment2.getId()).await();
+    segmentAddLathces.get(segment3.getId()).await();
+    segmentAddLathces.get(segment4.getId()).await();
+    segmentDropLatches.get(segment2.getId()).await();
 
     DruidServer druidServer = httpServerInventoryView.getInventoryValue("host:8080");
-    Assert.assertEquals(ImmutableMap.of(segment3.getIdentifier(), segment3, segment4.getIdentifier(), segment4),
-                        druidServer.getSegments());
+    Assert.assertEquals(
+        ImmutableMap.of(segment3.getId(), segment3, segment4.getId(), segment4),
+        Maps.uniqueIndex(druidServer.getSegments(), DataSegment::getId)
+    );
 
     druidNodeDiscovery.listener.nodesRemoved(ImmutableList.of(druidNode));
 
diff --git a/server/src/test/java/org/apache/druid/client/ImmutableDruidDataSourceTest.java b/server/src/test/java/org/apache/druid/client/ImmutableDruidDataSourceTest.java
index a2e8186e3a62..4514113013ab 100644
--- a/server/src/test/java/org/apache/druid/client/ImmutableDruidDataSourceTest.java
+++ b/server/src/test/java/org/apache/druid/client/ImmutableDruidDataSourceTest.java
@@ -53,7 +53,7 @@ public void testSerde() throws IOException
     final ImmutableDruidDataSource dataSource = new ImmutableDruidDataSource(
         "test",
         ImmutableMap.of("prop1", "val1", "prop2", "val2"),
-        ImmutableSortedMap.of(segment.getIdentifier(), segment)
+        ImmutableSortedMap.of(segment.getId(), segment)
     );
 
     final ObjectMapper objectMapper = new DefaultObjectMapper()
diff --git a/server/src/test/java/org/apache/druid/client/client/BatchServerInventoryViewTest.java b/server/src/test/java/org/apache/druid/client/client/BatchServerInventoryViewTest.java
index fa2fa440c268..6535940d270d 100644
--- a/server/src/test/java/org/apache/druid/client/client/BatchServerInventoryViewTest.java
+++ b/server/src/test/java/org/apache/druid/client/client/BatchServerInventoryViewTest.java
@@ -237,7 +237,7 @@ public void testRun() throws Exception
     waitForSync(batchServerInventoryView, testSegments);
 
     DruidServer server = Iterables.get(batchServerInventoryView.getInventory(), 0);
-    Set<DataSegment> segments = Sets.newHashSet(server.getSegments().values());
+    Set<DataSegment> segments = Sets.newHashSet(server.getSegments());
 
     Assert.assertEquals(testSegments, segments);
 
@@ -251,7 +251,7 @@ public void testRun() throws Exception
 
     waitForSync(batchServerInventoryView, testSegments);
 
-    Assert.assertEquals(testSegments, Sets.newHashSet(server.getSegments().values()));
+    Assert.assertEquals(testSegments, Sets.newHashSet(server.getSegments()));
 
     segmentAnnouncer.unannounceSegment(segment1);
     segmentAnnouncer.unannounceSegment(segment2);
@@ -260,7 +260,7 @@ public void testRun() throws Exception
 
     waitForSync(batchServerInventoryView, testSegments);
 
-    Assert.assertEquals(testSegments, Sets.newHashSet(server.getSegments().values()));
+    Assert.assertEquals(testSegments, Sets.newHashSet(server.getSegments()));
   }
 
   @Test
@@ -271,7 +271,7 @@ public void testRunWithFilter() throws Exception
     waitForSync(filteredBatchServerInventoryView, testSegments);
 
     DruidServer server = Iterables.get(filteredBatchServerInventoryView.getInventory(), 0);
-    Set<DataSegment> segments = Sets.newHashSet(server.getSegments().values());
+    Set<DataSegment> segments = Sets.newHashSet(server.getSegments());
 
     Assert.assertEquals(testSegments, segments);
     int prevUpdateCount = inventoryUpdateCounter.get();
@@ -283,7 +283,7 @@ public void testRunWithFilter() throws Exception
     waitForUpdateEvents(prevUpdateCount + 1);
     Assert.assertNull(
         Iterables.getOnlyElement(filteredBatchServerInventoryView.getInventory())
-                 .getSegment(segment1.getIdentifier())
+                 .getSegment(segment1.getId())
     );
   }
 
@@ -297,7 +297,7 @@ public void testRunWithFilterCallback() throws Exception
     waitForSync(filteredBatchServerInventoryView, testSegments);
 
     DruidServer server = Iterables.get(filteredBatchServerInventoryView.getInventory(), 0);
-    Set<DataSegment> segments = Sets.newHashSet(server.getSegments().values());
+    Set<DataSegment> segments = Sets.newHashSet(server.getSegments());
 
     Assert.assertEquals(testSegments, segments);
 
@@ -393,7 +393,8 @@ private static void waitForSync(BatchServerInventoryView batchServerInventoryVie
     final Timing forWaitingTiming = timing.forWaiting();
     Stopwatch stopwatch = Stopwatch.createStarted();
     while (Iterables.isEmpty(batchServerInventoryView.getInventory())
-           || Iterables.get(batchServerInventoryView.getInventory(), 0).getSegments().size() != testSegments.size()) {
+           || Iterables.size(Iterables.get(batchServerInventoryView.getInventory(), 0).getSegments()) !=
+              testSegments.size()) {
       Thread.sleep(100);
       if (stopwatch.elapsed(TimeUnit.MILLISECONDS) > forWaitingTiming.milliseconds()) {
         throw new ISE("BatchServerInventoryView is not updating");
@@ -425,7 +426,7 @@ public void testSameTimeZnode() throws Exception
     waitForSync(batchServerInventoryView, testSegments);
 
     DruidServer server = Iterables.get(batchServerInventoryView.getInventory(), 0);
-    final Set<DataSegment> segments = Sets.newHashSet(server.getSegments().values());
+    final Set<DataSegment> segments = Sets.newHashSet(server.getSegments());
 
     Assert.assertEquals(testSegments, segments);
 
@@ -493,7 +494,7 @@ public String getBase()
     Assert.assertEquals(INITIAL_SEGMENTS * 2, testSegments.size());
     waitForSync(batchServerInventoryView, testSegments);
 
-    Assert.assertEquals(testSegments, Sets.newHashSet(server.getSegments().values()));
+    Assert.assertEquals(testSegments, Sets.newHashSet(server.getSegments()));
 
     for (int i = 0; i < INITIAL_SEGMENTS; ++i) {
       final DataSegment segment = makeSegment(100 + i);
@@ -503,6 +504,6 @@ public String getBase()
 
     waitForSync(batchServerInventoryView, testSegments);
 
-    Assert.assertEquals(testSegments, Sets.newHashSet(server.getSegments().values()));
+    Assert.assertEquals(testSegments, Sets.newHashSet(server.getSegments()));
   }
 }
diff --git a/server/src/test/java/org/apache/druid/curator/CuratorTestBase.java b/server/src/test/java/org/apache/druid/curator/CuratorTestBase.java
index 3775f57768e9..98b264160735 100644
--- a/server/src/test/java/org/apache/druid/curator/CuratorTestBase.java
+++ b/server/src/test/java/org/apache/druid/curator/CuratorTestBase.java
@@ -106,10 +106,8 @@ protected void announceSegmentForServer(
       ObjectMapper jsonMapper
   )
   {
-    final String segmentAnnouncementPath = ZKPaths.makePath(ZKPaths.makePath(
-        zkPathsConfig.getLiveSegmentsPath(),
-        druidServer.getHost()
-    ), segment.getIdentifier());
+    final String segmentAnnouncementPath =
+        ZKPaths.makePath(zkPathsConfig.getLiveSegmentsPath(), druidServer.getHost(), segment.getId().toString());
 
     try {
       curator.create()
@@ -138,9 +136,9 @@ protected String announceBatchSegmentsForServer(
       ObjectMapper jsonMapper
   )
   {
-    final String segmentAnnouncementPath = ZKPaths.makePath(ZKPaths.makePath(
+    final String segmentAnnouncementPath = ZKPaths.makePath(
         zkPathsConfig.getLiveSegmentsPath(),
-        druidServer.getHost()),
+        druidServer.getHost(),
         UUIDUtils.generateUuid(
           druidServer.getHost(),
           druidServer.getType().toString(),
@@ -175,12 +173,12 @@ protected String announceBatchSegmentsForServer(
   protected void unannounceSegmentForServer(DruidServer druidServer, DataSegment segment, ZkPathsConfig zkPathsConfig)
       throws Exception
   {
-    curator.delete().guaranteed().forPath(
-        ZKPaths.makePath(
-            ZKPaths.makePath(zkPathsConfig.getLiveSegmentsPath(), druidServer.getHost()),
-            segment.getIdentifier()
-        )
+    String path = ZKPaths.makePath(
+        zkPathsConfig.getLiveSegmentsPath(),
+        druidServer.getHost(),
+        segment.getId().toString()
     );
+    curator.delete().guaranteed().forPath(path);
   }
 
   protected void unannounceSegmentFromBatchForServer(DruidServer druidServer, DataSegment segment, String batchPath, ZkPathsConfig zkPathsConfig)
diff --git a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
index f13105ebceab..b2ed94283fc9 100644
--- a/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/IndexerSQLMetadataStorageCoordinatorTest.java
@@ -30,7 +30,7 @@
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.segment.TestHelper;
-import org.apache.druid.segment.realtime.appenderator.SegmentIdentifier;
+import org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.LinearShardSpec;
 import org.apache.druid.timeline.partition.NoneShardSpec;
@@ -47,6 +47,7 @@
 import org.skife.jdbi.v2.util.StringMapper;
 
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicLong;
@@ -217,12 +218,11 @@ private void unUseSegment()
                 @Override
                 public Integer withHandle(Handle handle)
                 {
-                  return handle.createStatement(
-                      StringUtils.format(
-                          "UPDATE %s SET used = false WHERE id = :id",
-                          derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable()
-                      )
-                  ).bind("id", segment.getIdentifier()).execute();
+                  String request = StringUtils.format(
+                      "UPDATE %s SET used = false WHERE id = :id",
+                      derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable()
+                  );
+                  return handle.createStatement(request).bind("id", segment.getId().toString()).execute();
                 }
               }
           )
@@ -230,7 +230,7 @@ public Integer withHandle(Handle handle)
     }
   }
 
-  private List<String> getUsedIdentifiers()
+  private List<String> getUsedSegmentIds()
   {
     final String table = derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable();
     return derbyConnector.retryWithHandle(
@@ -253,19 +253,19 @@ public void testSimpleAnnounce() throws IOException
     coordinator.announceHistoricalSegments(SEGMENTS);
     for (DataSegment segment : SEGMENTS) {
       Assert.assertArrayEquals(
-          mapper.writeValueAsString(segment).getBytes("UTF-8"),
+          mapper.writeValueAsString(segment).getBytes(StandardCharsets.UTF_8),
           derbyConnector.lookup(
               derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable(),
               "id",
               "payload",
-              segment.getIdentifier()
+              segment.getId().toString()
           )
       );
     }
 
     Assert.assertEquals(
-        ImmutableList.of(defaultSegment.getIdentifier(), defaultSegment2.getIdentifier()),
-        getUsedIdentifiers()
+        ImmutableList.of(defaultSegment.getId().toString(), defaultSegment2.getId().toString()),
+        getUsedSegmentIds()
     );
 
     // Should not update dataSource metadata.
@@ -281,17 +281,17 @@ public void testOvershadowingAnnounce() throws IOException
 
     for (DataSegment segment : segments) {
       Assert.assertArrayEquals(
-          mapper.writeValueAsString(segment).getBytes("UTF-8"),
+          mapper.writeValueAsString(segment).getBytes(StandardCharsets.UTF_8),
           derbyConnector.lookup(
               derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable(),
               "id",
               "payload",
-              segment.getIdentifier()
+              segment.getId().toString()
           )
       );
     }
 
-    Assert.assertEquals(ImmutableList.of(defaultSegment4.getIdentifier()), getUsedIdentifiers());
+    Assert.assertEquals(ImmutableList.of(defaultSegment4.getId().toString()), getUsedSegmentIds());
   }
 
   @Test
@@ -306,12 +306,12 @@ public void testTransactionalAnnounceSuccess() throws IOException
     Assert.assertEquals(new SegmentPublishResult(ImmutableSet.of(defaultSegment), true), result1);
 
     Assert.assertArrayEquals(
-        mapper.writeValueAsString(defaultSegment).getBytes("UTF-8"),
+        mapper.writeValueAsString(defaultSegment).getBytes(StandardCharsets.UTF_8),
         derbyConnector.lookup(
             derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable(),
             "id",
             "payload",
-            defaultSegment.getIdentifier()
+            defaultSegment.getId().toString()
         )
     );
 
@@ -324,12 +324,12 @@ public void testTransactionalAnnounceSuccess() throws IOException
     Assert.assertEquals(new SegmentPublishResult(ImmutableSet.of(defaultSegment2), true), result2);
 
     Assert.assertArrayEquals(
-        mapper.writeValueAsString(defaultSegment2).getBytes("UTF-8"),
+        mapper.writeValueAsString(defaultSegment2).getBytes(StandardCharsets.UTF_8),
         derbyConnector.lookup(
             derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable(),
             "id",
             "payload",
-            defaultSegment2.getIdentifier()
+            defaultSegment2.getId().toString()
         )
     );
 
@@ -380,12 +380,12 @@ protected DataSourceMetadataUpdateResult updateDataSourceMetadataWithHandle(
     Assert.assertEquals(new SegmentPublishResult(ImmutableSet.of(defaultSegment), true), result1);
 
     Assert.assertArrayEquals(
-        mapper.writeValueAsString(defaultSegment).getBytes("UTF-8"),
+        mapper.writeValueAsString(defaultSegment).getBytes(StandardCharsets.UTF_8),
         derbyConnector.lookup(
             derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable(),
             "id",
             "payload",
-            defaultSegment.getIdentifier()
+            defaultSegment.getId().toString()
         )
     );
 
@@ -401,12 +401,12 @@ protected DataSourceMetadataUpdateResult updateDataSourceMetadataWithHandle(
     Assert.assertEquals(new SegmentPublishResult(ImmutableSet.of(defaultSegment2), true), result2);
 
     Assert.assertArrayEquals(
-        mapper.writeValueAsString(defaultSegment2).getBytes("UTF-8"),
+        mapper.writeValueAsString(defaultSegment2).getBytes(StandardCharsets.UTF_8),
         derbyConnector.lookup(
             derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable(),
             "id",
             "payload",
-            defaultSegment2.getIdentifier()
+            defaultSegment2.getId().toString()
         )
     );
 
@@ -817,19 +817,19 @@ private void additionalNumberedShardTest(Set<DataSegment> segments) throws IOExc
 
     for (DataSegment segment : segments) {
       Assert.assertArrayEquals(
-          mapper.writeValueAsString(segment).getBytes("UTF-8"),
+          mapper.writeValueAsString(segment).getBytes(StandardCharsets.UTF_8),
           derbyConnector.lookup(
               derbyConnectorRule.metadataTablesConfigSupplier().get().getSegmentsTable(),
               "id",
               "payload",
-              segment.getIdentifier()
+              segment.getId().toString()
           )
       );
     }
 
     Assert.assertEquals(
-        segments.stream().map(DataSegment::getIdentifier).collect(Collectors.toList()),
-        getUsedIdentifiers()
+        segments.stream().map(segment -> segment.getId().toString()).collect(Collectors.toList()),
+        getUsedSegmentIds()
     );
 
     // Should not update dataSource metadata.
@@ -841,7 +841,7 @@ public void testAllocatePendingSegment()
   {
     final String dataSource = "ds";
     final Interval interval = Intervals.of("2017-01-01/2017-02-01");
-    final SegmentIdentifier identifier = coordinator.allocatePendingSegment(
+    final SegmentIdWithShardSpec identifier = coordinator.allocatePendingSegment(
         dataSource,
         "seq",
         null,
@@ -852,7 +852,7 @@ public void testAllocatePendingSegment()
 
     Assert.assertEquals("ds_2017-01-01T00:00:00.000Z_2017-02-01T00:00:00.000Z_version", identifier.toString());
 
-    final SegmentIdentifier identifier1 = coordinator.allocatePendingSegment(
+    final SegmentIdWithShardSpec identifier1 = coordinator.allocatePendingSegment(
         dataSource,
         "seq",
         identifier.toString(),
@@ -863,7 +863,7 @@ public void testAllocatePendingSegment()
 
     Assert.assertEquals("ds_2017-01-01T00:00:00.000Z_2017-02-01T00:00:00.000Z_version_1", identifier1.toString());
 
-    final SegmentIdentifier identifier2 = coordinator.allocatePendingSegment(
+    final SegmentIdWithShardSpec identifier2 = coordinator.allocatePendingSegment(
         dataSource,
         "seq",
         identifier1.toString(),
@@ -874,7 +874,7 @@ public void testAllocatePendingSegment()
 
     Assert.assertEquals("ds_2017-01-01T00:00:00.000Z_2017-02-01T00:00:00.000Z_version_2", identifier2.toString());
 
-    final SegmentIdentifier identifier3 = coordinator.allocatePendingSegment(
+    final SegmentIdWithShardSpec identifier3 = coordinator.allocatePendingSegment(
         dataSource,
         "seq",
         identifier1.toString(),
@@ -886,7 +886,7 @@ public void testAllocatePendingSegment()
     Assert.assertEquals("ds_2017-01-01T00:00:00.000Z_2017-02-01T00:00:00.000Z_version_2", identifier3.toString());
     Assert.assertEquals(identifier2, identifier3);
 
-    final SegmentIdentifier identifier4 = coordinator.allocatePendingSegment(
+    final SegmentIdWithShardSpec identifier4 = coordinator.allocatePendingSegment(
         dataSource,
         "seq1",
         null,
@@ -908,7 +908,7 @@ public void testDeletePendingSegment() throws InterruptedException
     final DateTime begin = DateTimes.nowUtc();
 
     for (int i = 0; i < 10; i++) {
-      final SegmentIdentifier identifier = coordinator.allocatePendingSegment(
+      final SegmentIdWithShardSpec identifier = coordinator.allocatePendingSegment(
           dataSource,
           "seq",
           prevSegmentId,
@@ -922,7 +922,7 @@ public void testDeletePendingSegment() throws InterruptedException
 
     final DateTime secondBegin = DateTimes.nowUtc();
     for (int i = 0; i < 5; i++) {
-      final SegmentIdentifier identifier = coordinator.allocatePendingSegment(
+      final SegmentIdWithShardSpec identifier = coordinator.allocatePendingSegment(
           dataSource,
           "seq",
           prevSegmentId,
diff --git a/server/src/test/java/org/apache/druid/metadata/SQLMetadataSegmentManagerTest.java b/server/src/test/java/org/apache/druid/metadata/SQLMetadataSegmentManagerTest.java
index 4345aedd3a10..a9f8f3c5df00 100644
--- a/server/src/test/java/org/apache/druid/metadata/SQLMetadataSegmentManagerTest.java
+++ b/server/src/test/java/org/apache/druid/metadata/SQLMetadataSegmentManagerTest.java
@@ -121,11 +121,11 @@ public void testPoll()
     Assert.assertTrue(manager.isStarted());
     Assert.assertEquals(
         ImmutableList.of("wikipedia"),
-        manager.getAllDatasourceNames()
+        manager.getAllDataSourceNames()
     );
     Assert.assertEquals(
         ImmutableSet.of(segment1, segment2),
-        ImmutableSet.copyOf(manager.getInventoryValue("wikipedia").getSegments())
+        ImmutableSet.copyOf(manager.getDataSource("wikipedia").getSegments())
     );
   }
 
@@ -153,7 +153,7 @@ public void testPollWithCurroptedSegment()
     Assert.assertTrue(manager.isStarted());
 
     Assert.assertEquals(
-        "wikipedia", Iterables.getOnlyElement(manager.getInventory()).getName()
+        "wikipedia", Iterables.getOnlyElement(manager.getDataSources()).getName()
     );
   }
 
@@ -163,7 +163,7 @@ public void testGetUnusedSegmentsForInterval()
     manager.start();
     manager.poll();
     Assert.assertTrue(manager.isStarted());
-    Assert.assertTrue(manager.removeDatasource("wikipedia"));
+    Assert.assertTrue(manager.removeDataSource("wikipedia"));
 
     Assert.assertEquals(
         ImmutableList.of(segment2.getInterval()),
@@ -202,8 +202,8 @@ public void testRemoveDataSource() throws IOException
 
     publisher.publishSegment(newSegment);
 
-    Assert.assertNull(manager.getInventoryValue(newDataSource));
-    Assert.assertTrue(manager.removeDatasource(newDataSource));
+    Assert.assertNull(manager.getDataSource(newDataSource));
+    Assert.assertTrue(manager.removeDataSource(newDataSource));
   }
 
   @Test
@@ -232,8 +232,8 @@ public void testRemoveDataSegment() throws IOException
 
     publisher.publishSegment(newSegment);
 
-    Assert.assertNull(manager.getInventoryValue(newDataSource));
-    Assert.assertTrue(manager.removeSegment(newDataSource, newSegment.getIdentifier()));
+    Assert.assertNull(manager.getDataSource(newDataSource));
+    Assert.assertTrue(manager.removeSegment(newSegment.getId()));
   }
 
   @Test
diff --git a/server/src/test/java/org/apache/druid/segment/loading/CacheTestSegmentLoader.java b/server/src/test/java/org/apache/druid/segment/loading/CacheTestSegmentLoader.java
index dfee2bbe0d85..5723359b77ad 100644
--- a/server/src/test/java/org/apache/druid/segment/loading/CacheTestSegmentLoader.java
+++ b/server/src/test/java/org/apache/druid/segment/loading/CacheTestSegmentLoader.java
@@ -25,6 +25,7 @@
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.StorageAdapter;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.Interval;
 
 import java.io.File;
@@ -52,9 +53,9 @@ public Segment getSegment(final DataSegment segment)
     return new AbstractSegment()
     {
       @Override
-      public String getIdentifier()
+      public SegmentId getId()
       {
-        return segment.getIdentifier();
+        return segment.getId();
       }
 
       @Override
diff --git a/server/src/test/java/org/apache/druid/segment/loading/LocalDataSegmentFinderTest.java b/server/src/test/java/org/apache/druid/segment/loading/LocalDataSegmentFinderTest.java
index 5574bd6581ac..2e2af69cc709 100644
--- a/server/src/test/java/org/apache/druid/segment/loading/LocalDataSegmentFinderTest.java
+++ b/server/src/test/java/org/apache/druid/segment/loading/LocalDataSegmentFinderTest.java
@@ -160,15 +160,15 @@ public void testFindSegments() throws SegmentLoadingException, IOException
     DataSegment updatedSegment4_0 = null;
     DataSegment updatedSegment4_1 = null;
     for (DataSegment dataSegment : segments) {
-      if (dataSegment.getIdentifier().equals(SEGMENT_1.getIdentifier())) {
+      if (dataSegment.getId().equals(SEGMENT_1.getId())) {
         updatedSegment1 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_2.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_2.getId())) {
         updatedSegment2 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_3.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_3.getId())) {
         updatedSegment3 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_4_0.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_4_0.getId())) {
         updatedSegment4_0 = dataSegment;
-      } else if (dataSegment.getIdentifier().equals(SEGMENT_4_1.getIdentifier())) {
+      } else if (dataSegment.getId().equals(SEGMENT_4_1.getId())) {
         updatedSegment4_1 = dataSegment;
       } else {
         Assert.fail("Unexpected segment");
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/AppenderatorPlumberTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/AppenderatorPlumberTest.java
index d87841293b28..6ad0341acd8f 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/AppenderatorPlumberTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/AppenderatorPlumberTest.java
@@ -127,7 +127,7 @@ public void testSimpleIngestion() throws Exception
     
     Assert.assertEquals(1, plumber.getSegmentsView().size());
     
-    SegmentIdentifier si = plumber.getSegmentsView().values().toArray(new SegmentIdentifier[0])[0];
+    SegmentIdWithShardSpec si = plumber.getSegmentsView().values().toArray(new SegmentIdWithShardSpec[0])[0];
     
     Assert.assertEquals(3,
         appenderator.getRowCount(si));
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/AppenderatorTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/AppenderatorTest.java
index 95e059351323..1dd0830baa5c 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/AppenderatorTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/AppenderatorTest.java
@@ -58,7 +58,7 @@
 
 public class AppenderatorTest
 {
-  private static final List<SegmentIdentifier> IDENTIFIERS = ImmutableList.of(
+  private static final List<SegmentIdWithShardSpec> IDENTIFIERS = ImmutableList.of(
       SI("2000/2001", "A", 0),
       SI("2000/2001", "A", 1),
       SI("2001/2002", "A", 0)
@@ -129,12 +129,12 @@ public void testSimpleIngestion() throws Exception
           sorted(
               Lists.transform(
                   segmentsAndMetadata.getSegments(),
-                  new Function<DataSegment, SegmentIdentifier>()
+                  new Function<DataSegment, SegmentIdWithShardSpec>()
                   {
                     @Override
-                    public SegmentIdentifier apply(DataSegment input)
+                    public SegmentIdWithShardSpec apply(DataSegment input)
                     {
-                      return SegmentIdentifier.fromDataSegment(input);
+                      return SegmentIdWithShardSpec.fromDataSegment(input);
                     }
                   }
               )
@@ -743,9 +743,9 @@ public void testQueryBySegments() throws Exception
     }
   }
 
-  private static SegmentIdentifier SI(String interval, String version, int partitionNum)
+  private static SegmentIdWithShardSpec SI(String interval, String version, int partitionNum)
   {
-    return new SegmentIdentifier(
+    return new SegmentIdWithShardSpec(
         AppenderatorTester.DATASOURCE,
         Intervals.of(interval),
         version,
@@ -803,12 +803,10 @@ private static <T> List<T> sorted(final List<T> xs)
           @Override
           public int compare(T a, T b)
           {
-            if (a instanceof SegmentIdentifier && b instanceof SegmentIdentifier) {
-              return ((SegmentIdentifier) a).getIdentifierAsString()
-                                            .compareTo(((SegmentIdentifier) b).getIdentifierAsString());
+            if (a instanceof SegmentIdWithShardSpec && b instanceof SegmentIdWithShardSpec) {
+              return ((SegmentIdWithShardSpec) a).compareTo(((SegmentIdWithShardSpec) b));
             } else if (a instanceof DataSegment && b instanceof DataSegment) {
-              return ((DataSegment) a).getIdentifier()
-                                      .compareTo(((DataSegment) b).getIdentifier());
+              return ((DataSegment) a).getId().compareTo(((DataSegment) b).getId());
             } else {
               throw new IllegalStateException("WTF??");
             }
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriverTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriverTest.java
index 2175a70e787a..66e136aaf7d9 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriverTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/BatchAppenderatorDriverTest.java
@@ -122,12 +122,12 @@ public void testSimple() throws Exception
 
     Assert.assertEquals(
         ImmutableSet.of(
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0)),
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(0, 0))
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0)),
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(0, 0))
         ),
         published.getSegments()
                  .stream()
-                 .map(SegmentIdentifier::fromDataSegment)
+                 .map(SegmentIdWithShardSpec::fromDataSegment)
                  .collect(Collectors.toSet())
     );
 
@@ -158,13 +158,13 @@ public void testIncrementalPush() throws Exception
 
     Assert.assertEquals(
         ImmutableSet.of(
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0)),
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(0, 0)),
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(1, 0))
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0)),
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(0, 0)),
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(1, 0))
         ),
         published.getSegments()
                  .stream()
-                 .map(SegmentIdentifier::fromDataSegment)
+                 .map(SegmentIdWithShardSpec::fromDataSegment)
                  .collect(Collectors.toSet())
     );
 
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/CommittedTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/CommittedTest.java
index 3aeeb78b0b43..07608e59b693 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/CommittedTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/CommittedTest.java
@@ -34,30 +34,30 @@ public class CommittedTest
 {
   private static final ObjectMapper objectMapper = new DefaultObjectMapper();
 
-  private static final SegmentIdentifier IDENTIFIER_OBJECT1 = new SegmentIdentifier(
+  private static final SegmentIdWithShardSpec IDENTIFIER_OBJECT1 = new SegmentIdWithShardSpec(
       "foo",
       Intervals.of("2000/2001"),
       "2000",
       new LinearShardSpec(1)
   );
 
-  private static final SegmentIdentifier IDENTIFIER_OBJECT2 = new SegmentIdentifier(
+  private static final SegmentIdWithShardSpec IDENTIFIER_OBJECT2 = new SegmentIdWithShardSpec(
       "foo",
       Intervals.of("2001/2002"),
       "2001",
       new LinearShardSpec(1)
   );
 
-  private static final SegmentIdentifier IDENTIFIER_OBJECT3 = new SegmentIdentifier(
+  private static final SegmentIdWithShardSpec IDENTIFIER_OBJECT3 = new SegmentIdWithShardSpec(
       "foo",
       Intervals.of("2001/2002"),
       "2001",
       new LinearShardSpec(2)
   );
 
-  private static final String IDENTIFIER1 = IDENTIFIER_OBJECT1.getIdentifierAsString();
-  private static final String IDENTIFIER2 = IDENTIFIER_OBJECT2.getIdentifierAsString();
-  private static final String IDENTIFIER3 = IDENTIFIER_OBJECT3.getIdentifierAsString();
+  private static final String IDENTIFIER1 = IDENTIFIER_OBJECT1.toString();
+  private static final String IDENTIFIER2 = IDENTIFIER_OBJECT2.toString();
+  private static final String IDENTIFIER3 = IDENTIFIER_OBJECT3.toString();
 
   private static Committed fixedInstance()
   {
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/DefaultOfflineAppenderatorFactoryTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/DefaultOfflineAppenderatorFactoryTest.java
index 8e072804ee15..019b1097b869 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/DefaultOfflineAppenderatorFactoryTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/DefaultOfflineAppenderatorFactoryTest.java
@@ -160,7 +160,7 @@ public int columnCacheSizeBytes()
     )) {
       Assert.assertEquals("dataSourceName", appenderator.getDataSource());
       Assert.assertEquals(null, appenderator.startJob());
-      SegmentIdentifier identifier = new SegmentIdentifier(
+      SegmentIdWithShardSpec identifier = new SegmentIdWithShardSpec(
           "dataSourceName",
           Intervals.of("2000/2001"),
           "A",
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/SegmentIdentifierTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpecTest.java
similarity index 83%
rename from server/src/test/java/org/apache/druid/segment/realtime/appenderator/SegmentIdentifierTest.java
rename to server/src/test/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpecTest.java
index e0acfff0f161..55ff5892fd76 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/SegmentIdentifierTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpecTest.java
@@ -27,15 +27,15 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-public class SegmentIdentifierTest
+public class SegmentIdWithShardSpecTest
 {
   private static final String DATA_SOURCE = "foo";
   private static final Interval INTERVAL = Intervals.of("2000/PT1H");
   private static final String VERSION = "v1";
   private static final NumberedShardSpec SHARD_SPEC_0 = new NumberedShardSpec(0, 2);
   private static final NumberedShardSpec SHARD_SPEC_1 = new NumberedShardSpec(1, 2);
-  private static final SegmentIdentifier ID_0 = new SegmentIdentifier(DATA_SOURCE, INTERVAL, VERSION, SHARD_SPEC_0);
-  private static final SegmentIdentifier ID_1 = new SegmentIdentifier(DATA_SOURCE, INTERVAL, VERSION, SHARD_SPEC_1);
+  private static final SegmentIdWithShardSpec ID_0 = new SegmentIdWithShardSpec(DATA_SOURCE, INTERVAL, VERSION, SHARD_SPEC_0);
+  private static final SegmentIdWithShardSpec ID_1 = new SegmentIdWithShardSpec(DATA_SOURCE, INTERVAL, VERSION, SHARD_SPEC_1);
 
   @Test
   public void testSerde() throws Exception
@@ -43,9 +43,9 @@ public void testSerde() throws Exception
     final ObjectMapper objectMapper = new DefaultObjectMapper();
     objectMapper.registerSubtypes(NumberedShardSpec.class);
 
-    final SegmentIdentifier id2 = objectMapper.readValue(
+    final SegmentIdWithShardSpec id2 = objectMapper.readValue(
         objectMapper.writeValueAsBytes(ID_1),
-        SegmentIdentifier.class
+        SegmentIdWithShardSpec.class
     );
 
     Assert.assertEquals(ID_1, id2);
@@ -59,7 +59,7 @@ public void testSerde() throws Exception
   @Test
   public void testAsString()
   {
-    Assert.assertEquals("foo_2000-01-01T00:00:00.000Z_2000-01-01T01:00:00.000Z_v1", ID_0.getIdentifierAsString());
-    Assert.assertEquals("foo_2000-01-01T00:00:00.000Z_2000-01-01T01:00:00.000Z_v1_1", ID_1.getIdentifierAsString());
+    Assert.assertEquals("foo_2000-01-01T00:00:00.000Z_2000-01-01T01:00:00.000Z_v1", ID_0.toString());
+    Assert.assertEquals("foo_2000-01-01T00:00:00.000Z_2000-01-01T01:00:00.000Z_v1_1", ID_1.toString());
   }
 }
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverFailTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverFailTest.java
index 4867691d8053..cb319c8b7c2a 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverFailTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverFailTest.java
@@ -327,7 +327,7 @@ private void testFailDuringPublishInternal(boolean failWithException) throws Exc
   private static class NoopUsedSegmentChecker implements UsedSegmentChecker
   {
     @Override
-    public Set<DataSegment> findUsedSegments(Set<SegmentIdentifier> identifiers)
+    public Set<DataSegment> findUsedSegments(Set<SegmentIdWithShardSpec> identifiers)
     {
       return ImmutableSet.of();
     }
@@ -355,7 +355,7 @@ static Appenderator createDropFailAppenderator()
 
   private static class FailableAppenderator implements Appenderator
   {
-    private final Map<SegmentIdentifier, List<InputRow>> rows = new HashMap<>();
+    private final Map<SegmentIdWithShardSpec, List<InputRow>> rows = new HashMap<>();
 
     private boolean dropEnabled = true;
     private boolean persistEnabled = true;
@@ -404,7 +404,7 @@ public Object startJob()
 
     @Override
     public AppenderatorAddResult add(
-        SegmentIdentifier identifier,
+        SegmentIdWithShardSpec identifier,
         InputRow row,
         Supplier<Committer> committerSupplier,
         boolean allowIncrementalPersists
@@ -416,13 +416,13 @@ public AppenderatorAddResult add(
     }
 
     @Override
-    public List<SegmentIdentifier> getSegments()
+    public List<SegmentIdWithShardSpec> getSegments()
     {
       return ImmutableList.copyOf(rows.keySet());
     }
 
     @Override
-    public int getRowCount(SegmentIdentifier identifier)
+    public int getRowCount(SegmentIdWithShardSpec identifier)
     {
       final List<InputRow> rows = this.rows.get(identifier);
       if (rows != null) {
@@ -445,7 +445,7 @@ public void clear()
     }
 
     @Override
-    public ListenableFuture<?> drop(SegmentIdentifier identifier)
+    public ListenableFuture<?> drop(SegmentIdWithShardSpec identifier)
     {
       if (dropEnabled) {
         rows.remove(identifier);
@@ -468,7 +468,7 @@ public ListenableFuture<Object> persistAll(Committer committer)
 
     @Override
     public ListenableFuture<SegmentsAndMetadata> push(
-        Collection<SegmentIdentifier> identifiers, Committer committer, boolean useUniquePath
+        Collection<SegmentIdWithShardSpec> identifiers, Committer committer, boolean useUniquePath
     )
     {
       if (pushEnabled) {
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverTest.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverTest.java
index 421cc5700845..d16d4e817c9e 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverTest.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/StreamAppenderatorDriverTest.java
@@ -155,8 +155,8 @@ public void testSimple() throws Exception
 
     Assert.assertEquals(
         ImmutableSet.of(
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0)),
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(0, 0))
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0)),
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(0, 0))
         ),
         asIdentifiers(segmentsAndMetadata.getSegments())
     );
@@ -252,7 +252,7 @@ public void testPublishPerRow() throws IOException, InterruptedException, Timeou
 
       Assert.assertEquals(
           ImmutableSet.of(
-              new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0))
+              new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0))
           ),
           asIdentifiers(segmentsAndMetadata.getSegments())
       );
@@ -275,7 +275,7 @@ public void testPublishPerRow() throws IOException, InterruptedException, Timeou
           ImmutableSet.of(
               // The second and third rows have the same dataSource, interval, and version, but different shardSpec of
               // different partitionNum
-              new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(i - 1, 0))
+              new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(i - 1, 0))
           ),
           asIdentifiers(segmentsAndMetadata.getSegments())
       );
@@ -338,14 +338,14 @@ public void testIncrementalHandoff() throws Exception
 
     Assert.assertEquals(
         ImmutableSet.of(
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0))
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000/PT1H"), VERSION, new NumberedShardSpec(0, 0))
         ),
         asIdentifiers(handedoffFromSequence0.getSegments())
     );
 
     Assert.assertEquals(
         ImmutableSet.of(
-            new SegmentIdentifier(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(0, 0))
+            new SegmentIdWithShardSpec(DATA_SOURCE, Intervals.of("2000T01/PT1H"), VERSION, new NumberedShardSpec(0, 0))
         ),
         asIdentifiers(handedoffFromSequence1.getSegments())
     );
@@ -354,9 +354,9 @@ public void testIncrementalHandoff() throws Exception
     Assert.assertEquals(3, handedoffFromSequence1.getCommitMetadata());
   }
 
-  private Set<SegmentIdentifier> asIdentifiers(Iterable<DataSegment> segments)
+  private Set<SegmentIdWithShardSpec> asIdentifiers(Iterable<DataSegment> segments)
   {
-    return ImmutableSet.copyOf(Iterables.transform(segments, SegmentIdentifier::fromDataSegment));
+    return ImmutableSet.copyOf(Iterables.transform(segments, SegmentIdWithShardSpec::fromDataSegment));
   }
 
   static TransactionalSegmentPublisher makeOkPublisher()
@@ -417,7 +417,7 @@ public TestSegmentAllocator(String dataSource, Granularity granularity)
     }
 
     @Override
-    public SegmentIdentifier allocate(
+    public SegmentIdWithShardSpec allocate(
         final InputRow row,
         final String sequenceName,
         final String previousSegmentId,
@@ -431,7 +431,7 @@ public SegmentIdentifier allocate(
           counters.put(timestampTruncated, new AtomicInteger());
         }
         final int partitionNum = counters.get(timestampTruncated).getAndIncrement();
-        return new SegmentIdentifier(
+        return new SegmentIdWithShardSpec(
             dataSource,
             granularity.bucket(dateTimeTruncated),
             VERSION,
diff --git a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/TestUsedSegmentChecker.java b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/TestUsedSegmentChecker.java
index de53f890e9c0..d8a2c98b242b 100644
--- a/server/src/test/java/org/apache/druid/segment/realtime/appenderator/TestUsedSegmentChecker.java
+++ b/server/src/test/java/org/apache/druid/segment/realtime/appenderator/TestUsedSegmentChecker.java
@@ -38,7 +38,7 @@ public TestUsedSegmentChecker(AppenderatorTester appenderatorTester)
   }
 
   @Override
-  public Set<DataSegment> findUsedSegments(Set<SegmentIdentifier> identifiers)
+  public Set<DataSegment> findUsedSegments(Set<SegmentIdWithShardSpec> identifiers)
   {
     final VersionedIntervalTimeline<String, DataSegment> timeline = new VersionedIntervalTimeline<>(Ordering.natural());
     for (DataSegment dataSegment : appenderatorTester.getPushedSegments()) {
@@ -50,10 +50,10 @@ public Set<DataSegment> findUsedSegments(Set<SegmentIdentifier> identifiers)
     }
 
     final Set<DataSegment> retVal = Sets.newHashSet();
-    for (SegmentIdentifier identifier : identifiers) {
+    for (SegmentIdWithShardSpec identifier : identifiers) {
       for (TimelineObjectHolder<String, DataSegment> holder : timeline.lookup(identifier.getInterval())) {
         for (PartitionChunk<DataSegment> chunk : holder.getObject()) {
-          if (identifiers.contains(SegmentIdentifier.fromDataSegment(chunk.getObject()))) {
+          if (identifiers.contains(SegmentIdWithShardSpec.fromDataSegment(chunk.getObject()))) {
             retVal.add(chunk.getObject());
           }
         }
diff --git a/server/src/test/java/org/apache/druid/server/SegmentManagerTest.java b/server/src/test/java/org/apache/druid/server/SegmentManagerTest.java
index aaa1b04a89fb..310173503cb5 100644
--- a/server/src/test/java/org/apache/druid/server/SegmentManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/SegmentManagerTest.java
@@ -34,6 +34,7 @@
 import org.apache.druid.segment.loading.SegmentLoadingException;
 import org.apache.druid.server.SegmentManager.DataSourceState;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.joda.time.Interval;
@@ -89,10 +90,7 @@ private static class SegmentForTesting extends AbstractSegment
     private final String version;
     private final Interval interval;
 
-    SegmentForTesting(
-        String version,
-        Interval interval
-    )
+    SegmentForTesting(String version, Interval interval)
     {
       this.version = version;
       this.interval = interval;
@@ -109,9 +107,9 @@ public Interval getInterval()
     }
 
     @Override
-    public String getIdentifier()
+    public SegmentId getId()
     {
-      return version;
+      return SegmentId.dummy(version);
     }
 
     @Override
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentChangeRequestDropTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentChangeRequestDropTest.java
index c8ad82422e75..fb1cd69a144a 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentChangeRequestDropTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentChangeRequestDropTest.java
@@ -61,7 +61,8 @@ public void testV1Serialization() throws Exception
     final SegmentChangeRequestDrop segmentDrop = new SegmentChangeRequestDrop(segment);
 
     Map<String, Object> objectMap = mapper.readValue(
-        mapper.writeValueAsString(segmentDrop), JacksonUtils.TYPE_REFERENCE_MAP_STRING_OBJECT
+        mapper.writeValueAsString(segmentDrop),
+        JacksonUtils.TYPE_REFERENCE_MAP_STRING_OBJECT
     );
 
     Assert.assertEquals(11, objectMap.size());
diff --git a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
index 4799f3f2c1a4..d078d38297e2 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/SegmentLoadDropHandlerTest.java
@@ -45,14 +45,16 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
 
 /**
  */
@@ -273,7 +275,7 @@ Because another addSegment() call is executed, which removes the segment from se
   @Test
   public void testLoadCache() throws Exception
   {
-    List<DataSegment> segments = new ArrayList<>();
+    Set<DataSegment> segments = new HashSet<>();
     for (int i = 0; i < COUNT; ++i) {
       segments.add(makeSegment("test" + i, "1", Intervals.of("P1d/2011-04-01")));
       segments.add(makeSegment("test" + i, "1", Intervals.of("P1d/2011-04-02")));
@@ -289,7 +291,6 @@ public void testLoadCache() throws Exception
       segments.add(makeSegment("test_two" + i, "1", Intervals.of("P1d/2011-04-01")));
       segments.add(makeSegment("test_two" + i, "1", Intervals.of("P1d/2011-04-02")));
     }
-    Collections.sort(segments);
 
     for (DataSegment segment : segments) {
       writeSegmentToCache(segment);
@@ -335,10 +336,7 @@ private void writeSegmentToCache(final DataSegment segment)
       infoDir.mkdir();
     }
 
-    File segmentInfoCacheFile = new File(
-        infoDir,
-        segment.getIdentifier()
-    );
+    File segmentInfoCacheFile = new File(infoDir, segment.getId().toString());
     try {
       jsonMapper.writeValue(segmentInfoCacheFile, segment);
     }
@@ -351,10 +349,7 @@ private void writeSegmentToCache(final DataSegment segment)
 
   private void deleteSegmentFromCache(final DataSegment segment)
   {
-    File segmentInfoCacheFile = new File(
-        infoDir,
-        segment.getIdentifier()
-    );
+    File segmentInfoCacheFile = new File(infoDir, segment.getId().toString());
     if (segmentInfoCacheFile.exists()) {
       segmentInfoCacheFile.delete();
     }
@@ -362,19 +357,23 @@ private void deleteSegmentFromCache(final DataSegment segment)
     Assert.assertTrue(!segmentInfoCacheFile.exists());
   }
 
-  private void checkCache(List<DataSegment> segments) throws IOException
+  private void checkCache(Set<DataSegment> expectedSegments)
   {
     Assert.assertTrue(infoDir.exists());
     File[] files = infoDir.listFiles();
 
-    List<File> sortedFiles = Arrays.asList(files);
-    Collections.sort(sortedFiles);
-
-    Assert.assertEquals(segments.size(), sortedFiles.size());
-    for (int i = 0; i < sortedFiles.size(); i++) {
-      DataSegment segment = jsonMapper.readValue(sortedFiles.get(i), DataSegment.class);
-      Assert.assertEquals(segments.get(i), segment);
-    }
+    Set<DataSegment> segmentsInFiles = Arrays
+        .stream(files)
+        .map(file -> {
+          try {
+            return jsonMapper.readValue(file, DataSegment.class);
+          }
+          catch (IOException e) {
+            throw new RuntimeException(e);
+          }
+        })
+        .collect(Collectors.toSet());
+    Assert.assertEquals(expectedSegments, segmentsInFiles);
   }
 
   @Test
@@ -405,7 +404,7 @@ public int getAnnounceIntervalMillis()
         announcer, EasyMock.createNiceMock(DataSegmentServerAnnouncer.class), segmentManager
     );
 
-    List<DataSegment> segments = new ArrayList<>();
+    Set<DataSegment> segments = new HashSet<>();
     for (int i = 0; i < COUNT; ++i) {
       segments.add(makeSegment("test" + i, "1", Intervals.of("P1d/2011-04-01")));
       segments.add(makeSegment("test" + i, "1", Intervals.of("P1d/2011-04-02")));
@@ -413,7 +412,6 @@ public int getAnnounceIntervalMillis()
       segments.add(makeSegment("test_two" + i, "1", Intervals.of("P1d/2011-04-01")));
       segments.add(makeSegment("test_two" + i, "1", Intervals.of("P1d/2011-04-02")));
     }
-    Collections.sort(segments);
 
     for (DataSegment segment : segments) {
       writeSegmentToCache(segment);
diff --git a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
index 3107539e6f6c..85a42bf5dfce 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ServerManagerTest.java
@@ -70,6 +70,7 @@
 import org.apache.druid.server.initialization.ServerConfig;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.joda.time.Interval;
 import org.junit.Assert;
@@ -627,9 +628,9 @@ public Interval getInterval()
     }
 
     @Override
-    public String getIdentifier()
+    public SegmentId getId()
     {
-      return version;
+      return SegmentId.dummy(version);
     }
 
     public boolean isClosed()
diff --git a/server/src/test/java/org/apache/druid/server/coordination/ZkCoordinatorTest.java b/server/src/test/java/org/apache/druid/server/coordination/ZkCoordinatorTest.java
index d1ee59fd8ef8..6a6fafc04cb9 100644
--- a/server/src/test/java/org/apache/druid/server/coordination/ZkCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordination/ZkCoordinatorTest.java
@@ -112,7 +112,7 @@ public void testLoadDrop() throws Exception
       @Override
       public void addSegment(DataSegment s, DataSegmentChangeCallback callback)
       {
-        if (segment.getIdentifier().equals(s.getIdentifier())) {
+        if (segment.getId().equals(s.getId())) {
           loadLatch.countDown();
           callback.execute();
         }
@@ -121,7 +121,7 @@ public void addSegment(DataSegment s, DataSegmentChangeCallback callback)
       @Override
       public void removeSegment(DataSegment s, DataSegmentChangeCallback callback)
       {
-        if (segment.getIdentifier().equals(s.getIdentifier())) {
+        if (segment.getId().equals(s.getId())) {
           dropLatch.countDown();
           callback.execute();
         }
@@ -137,7 +137,7 @@ public void removeSegment(DataSegment s, DataSegmentChangeCallback callback)
     );
     zkCoordinator.start();
 
-    String segmentZkPath = ZKPaths.makePath(zkPaths.getLoadQueuePath(), me.getName(), segment.getIdentifier());
+    String segmentZkPath = ZKPaths.makePath(zkPaths.getLoadQueuePath(), me.getName(), segment.getId().toString());
 
     curator.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath(
         segmentZkPath, jsonMapper.writeValueAsBytes(new SegmentChangeRequestLoad(segment)));
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/CostBalancerStrategyTest.java b/server/src/test/java/org/apache/druid/server/coordinator/CostBalancerStrategyTest.java
index 8e26a959a918..d29e7ee463c0 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/CostBalancerStrategyTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/CostBalancerStrategyTest.java
@@ -30,16 +30,20 @@
 import org.apache.druid.server.coordination.DruidServerMetadata;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.easymock.EasyMock;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 public class CostBalancerStrategyTest
 {
@@ -56,22 +60,24 @@ public static List<ServerHolder> setupDummyCluster(int serverCount, int maxSegme
     // Each having having 100 segments
     for (int i = 0; i < serverCount; i++) {
       LoadQueuePeonTester fromPeon = new LoadQueuePeonTester();
-      Map<String, DataSegment> segments = Maps.newHashMap();
-      for (int j = 0; j < maxSegments; j++) {
-        DataSegment segment = getSegment(j);
-        segments.put(segment.getIdentifier(), segment);
-      }
-
-      serverHolderList.add(
-          new ServerHolder(
-              new ImmutableDruidServer(
-                  new DruidServerMetadata("DruidServer_Name_" + i, "localhost", null, 10000000L, ServerType.HISTORICAL, "hot", 1),
-                  3000L,
-                  ImmutableMap.of("DUMMY", EasyMock.createMock(ImmutableDruidDataSource.class)),
-                  ImmutableMap.copyOf(segments)
-              ),
-              fromPeon
-          ));
+
+      List<DataSegment> segments = IntStream
+          .range(0, maxSegments)
+          .mapToObj(j -> getSegment(j))
+          .collect(Collectors.toList());
+      ImmutableDruidDataSource dataSource = new ImmutableDruidDataSource("DUMMY", Collections.emptyMap(), segments);
+
+      String serverName = "DruidServer_Name_" + i;
+      ServerHolder serverHolder = new ServerHolder(
+          new ImmutableDruidServer(
+              new DruidServerMetadata(serverName, "localhost", null, 10000000L, ServerType.HISTORICAL, "hot", 1),
+              3000L,
+              ImmutableMap.of("DUMMY", dataSource),
+              segments.size()
+          ),
+          fromPeon
+      );
+      serverHolderList.add(serverHolder);
     }
 
     // The best server to be available for next segment assignment has only 98 Segments
@@ -82,13 +88,13 @@ public static List<ServerHolder> setupDummyCluster(int serverCount, int maxSegme
     EasyMock.expect(druidServer.getMaxSize()).andReturn(10000000L).anyTimes();
 
     EasyMock.expect(druidServer.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
-    Map<String, DataSegment> segments = Maps.newHashMap();
+    Map<SegmentId, DataSegment> segments = Maps.newHashMap();
     for (int j = 0; j < (maxSegments - 2); j++) {
       DataSegment segment = getSegment(j);
-      segments.put(segment.getIdentifier(), segment);
-      EasyMock.expect(druidServer.getSegment(segment.getIdentifier())).andReturn(segment).anyTimes();
+      segments.put(segment.getId(), segment);
+      EasyMock.expect(druidServer.getSegment(segment.getId())).andReturn(segment).anyTimes();
     }
-    EasyMock.expect(druidServer.getSegments()).andReturn(segments).anyTimes();
+    EasyMock.expect(druidServer.getSegments()).andReturn(segments.values()).anyTimes();
 
     EasyMock.replay(druidServer);
     serverHolderList.add(new ServerHolder(druidServer, fromPeon));
@@ -137,7 +143,6 @@ public void testCostBalancerSingleThreadStrategy()
     List<ServerHolder> serverHolderList = setupDummyCluster(10, 20);
     DataSegment segment = getSegment(1000);
 
-    final DateTime referenceTimestamp = DateTimes.of("2014-01-01");
     BalancerStrategy strategy = new CostBalancerStrategy(
         MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1))
     );
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/CuratorDruidCoordinatorTest.java b/server/src/test/java/org/apache/druid/server/coordinator/CuratorDruidCoordinatorTest.java
index 0e52e668e574..a3a292d72d8d 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/CuratorDruidCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/CuratorDruidCoordinatorTest.java
@@ -25,6 +25,9 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
+import org.apache.curator.framework.recipes.cache.PathChildrenCache;
+import org.apache.curator.framework.recipes.cache.PathChildrenCacheEvent;
+import org.apache.curator.utils.ZKPaths;
 import org.apache.druid.client.BatchServerInventoryView;
 import org.apache.druid.client.CoordinatorServerView;
 import org.apache.druid.client.DruidServer;
@@ -48,10 +51,8 @@
 import org.apache.druid.server.lookup.cache.LookupCoordinatorManager;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.timeline.partition.NoneShardSpec;
-import org.apache.curator.framework.recipes.cache.PathChildrenCache;
-import org.apache.curator.framework.recipes.cache.PathChildrenCacheEvent;
-import org.apache.curator.utils.ZKPaths;
 import org.easymock.EasyMock;
 import org.joda.time.Duration;
 import org.junit.After;
@@ -347,9 +348,9 @@ public void testMoveSegment() throws Exception
     segmentAddedLatch = new CountDownLatch(1);
 
     ImmutableDruidDataSource druidDataSource = EasyMock.createNiceMock(ImmutableDruidDataSource.class);
-    EasyMock.expect(druidDataSource.getSegment(EasyMock.anyString())).andReturn(sourceSegments.get(2));
+    EasyMock.expect(druidDataSource.getSegment(EasyMock.anyObject(SegmentId.class))).andReturn(sourceSegments.get(2));
     EasyMock.replay(druidDataSource);
-    EasyMock.expect(databaseSegmentManager.getInventoryValue(EasyMock.anyString())).andReturn(druidDataSource);
+    EasyMock.expect(databaseSegmentManager.getDataSource(EasyMock.anyString())).andReturn(druidDataSource);
     EasyMock.replay(databaseSegmentManager);
 
     coordinator.moveSegment(
@@ -363,18 +364,18 @@ public void testMoveSegment() throws Exception
     Assert.assertTrue(timing.forWaiting().awaitLatch(segmentAddedLatch));
 
     // remove load queue key from destination server to trigger adding drop to load queue
-    curator.delete().guaranteed().forPath(ZKPaths.makePath(DESTINATION_LOAD_PATH, segmentToMove.getIdentifier()));
+    curator.delete().guaranteed().forPath(ZKPaths.makePath(DESTINATION_LOAD_PATH, segmentToMove.getId().toString()));
 
     // wait for drop
     Assert.assertTrue(timing.forWaiting().awaitLatch(segmentRemovedLatch));
 
     // clean up drop from load queue
-    curator.delete().guaranteed().forPath(ZKPaths.makePath(SOURCE_LOAD_PATH, segmentToMove.getIdentifier()));
+    curator.delete().guaranteed().forPath(ZKPaths.makePath(SOURCE_LOAD_PATH, segmentToMove.getId().toString()));
 
     List<DruidServer> servers = serverView.getInventory().stream().collect(Collectors.toList());
 
-    Assert.assertEquals(2, servers.get(0).getSegments().size());
-    Assert.assertEquals(2, servers.get(1).getSegments().size());
+    Assert.assertEquals(2, servers.get(0).getTotalSegments());
+    Assert.assertEquals(2, servers.get(1).getTotalSegments());
   }
 
   private static class TestDruidLeaderSelector implements DruidLeaderSelector
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DiskNormalizedCostBalancerStrategyTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DiskNormalizedCostBalancerStrategyTest.java
index 88fe93a88ed6..8ec026724238 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DiskNormalizedCostBalancerStrategyTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DiskNormalizedCostBalancerStrategyTest.java
@@ -21,7 +21,6 @@
 
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.MoreExecutors;
 import org.apache.druid.client.ImmutableDruidDataSource;
 import org.apache.druid.client.ImmutableDruidServer;
@@ -34,10 +33,13 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 public class DiskNormalizedCostBalancerStrategyTest
 {
@@ -54,19 +56,20 @@ public static List<ServerHolder> setupDummyCluster(int serverCount, int maxSegme
     // Each having having 100 segments
     for (int i = 0; i < serverCount; i++) {
       LoadQueuePeonTester fromPeon = new LoadQueuePeonTester();
-      Map<String, DataSegment> segments = Maps.newHashMap();
-      for (int j = 0; j < maxSegments; j++) {
-        DataSegment segment = getSegment(j);
-        segments.put(segment.getIdentifier(), segment);
-      }
+
+      List<DataSegment> segments = IntStream
+          .range(0, maxSegments)
+          .mapToObj(j -> getSegment(j))
+          .collect(Collectors.toList());
+      ImmutableDruidDataSource dataSource = new ImmutableDruidDataSource("DUMMY", Collections.emptyMap(), segments);
 
       serverHolderList.add(
           new ServerHolder(
               new ImmutableDruidServer(
                   new DruidServerMetadata("DruidServer_Name_" + i, "localhost", null, 10000000L, ServerType.HISTORICAL, "hot", 1),
                   3000L,
-                  ImmutableMap.of("DUMMY", EasyMock.createMock(ImmutableDruidDataSource.class)),
-                  ImmutableMap.copyOf(segments)
+                  ImmutableMap.of("DUMMY", dataSource),
+                  segments.size()
               ),
               fromPeon
           ));
@@ -80,11 +83,11 @@ public static List<ServerHolder> setupDummyCluster(int serverCount, int maxSegme
     EasyMock.expect(druidServer.getMaxSize()).andReturn(100000000L).anyTimes();
 
     EasyMock.expect(druidServer.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
-    Map<String, DataSegment> segments = Maps.newHashMap();
+    List<DataSegment> segments = new ArrayList<>();
     for (int j = 0; j < maxSegments; j++) {
       DataSegment segment = getSegment(j);
-      segments.put(segment.getIdentifier(), segment);
-      EasyMock.expect(druidServer.getSegment(segment.getIdentifier())).andReturn(segment).anyTimes();
+      segments.add(segment);
+      EasyMock.expect(druidServer.getSegment(segment.getId())).andReturn(segment).anyTimes();
     }
     EasyMock.expect(druidServer.getSegments()).andReturn(segments).anyTimes();
 
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DruidClusterTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DruidClusterTest.java
index 62f35dc1deed..c07830e1320c 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DruidClusterTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DruidClusterTest.java
@@ -39,7 +39,6 @@
 import java.util.Map;
 import java.util.NavigableSet;
 import java.util.Set;
-import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -72,32 +71,16 @@ public class DruidClusterTest
   );
 
   private static final Map<String, ImmutableDruidDataSource> dataSources = ImmutableMap.of(
-      "src1",
-      new ImmutableDruidDataSource(
-          "src1",
-          Collections.emptyMap(),
-          new TreeMap<>()
-      ),
-      "src2",
-      new ImmutableDruidDataSource(
-          "src2",
-          Collections.emptyMap(),
-          new TreeMap<>()
-      )
+      "src1", new ImmutableDruidDataSource("src1", Collections.emptyMap(), Collections.singletonList(segments.get(0))),
+      "src2", new ImmutableDruidDataSource("src2", Collections.emptyMap(), Collections.singletonList(segments.get(0)))
   );
 
   private static final ServerHolder newRealtime = new ServerHolder(
       new ImmutableDruidServer(
           new DruidServerMetadata("name1", "host2", null, 100L, ServerType.REALTIME, "tier1", 0),
           0L,
-          ImmutableMap.of(
-              "src1",
-              dataSources.get("src1")
-          ),
-          ImmutableMap.of(
-              "segment1",
-              segments.get(0)
-          )
+          ImmutableMap.of("src1", dataSources.get("src1")),
+          1
       ),
       new LoadQueuePeonTester()
   );
@@ -106,14 +89,8 @@ public class DruidClusterTest
       new ImmutableDruidServer(
           new DruidServerMetadata("name1", "host2", null, 100L, ServerType.HISTORICAL, "tier1", 0),
           0L,
-          ImmutableMap.of(
-              "src1",
-              dataSources.get("src1")
-          ),
-          ImmutableMap.of(
-              "segment1",
-              segments.get(0)
-          )
+          ImmutableMap.of("src1", dataSources.get("src1")),
+          1
       ),
       new LoadQueuePeonTester()
   );
@@ -129,14 +106,8 @@ public void setup()
                 new ImmutableDruidServer(
                     new DruidServerMetadata("name1", "host1", null, 100L, ServerType.REALTIME, "tier1", 0),
                     0L,
-                    ImmutableMap.of(
-                        "src1",
-                        dataSources.get("src1")
-                    ),
-                    ImmutableMap.of(
-                        "segment1",
-                        segments.get(0)
-                    )
+                    ImmutableMap.of("src1", dataSources.get("src1")),
+                    1
                 ),
                 new LoadQueuePeonTester()
             )
@@ -148,14 +119,8 @@ public void setup()
                     new ImmutableDruidServer(
                         new DruidServerMetadata("name1", "host1", null, 100L, ServerType.HISTORICAL, "tier1", 0),
                         0L,
-                        ImmutableMap.of(
-                            "src1",
-                            dataSources.get("src1")
-                        ),
-                        ImmutableMap.of(
-                            "segment1",
-                            segments.get(0)
-                        )
+                        ImmutableMap.of("src1", dataSources.get("src1")),
+                        1
                     ),
                     new LoadQueuePeonTester()
                 )
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerProfiler.java b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerProfiler.java
index c505657c9afd..978cc44a6ee2 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerProfiler.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerProfiler.java
@@ -41,7 +41,8 @@
 import org.joda.time.Period;
 import org.junit.Before;
 
-import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeSet;
@@ -54,7 +55,7 @@ public class DruidCoordinatorBalancerProfiler
   private DruidCoordinator coordinator;
   private ImmutableDruidServer druidServer1;
   private ImmutableDruidServer druidServer2;
-  Map<String, DataSegment> segments = Maps.newHashMap();
+  List<DataSegment> segments = new ArrayList<>();
   ServiceEmitter emitter;
   MetadataRuleManager manager;
   PeriodLoadRule loadRule = new PeriodLoadRule(new Period("P5000Y"), ImmutableMap.of("normal", 3));
@@ -93,10 +94,9 @@ public void bigProfiler()
     List<DruidServer> serverList = Lists.newArrayList();
     Map<String, LoadQueuePeon> peonMap = Maps.newHashMap();
     List<ServerHolder> serverHolderList = Lists.newArrayList();
-    Map<String, DataSegment> segmentMap = Maps.newHashMap();
+    List<DataSegment> segments = new ArrayList<>();
     for (int i = 0; i < numSegments; i++) {
-      segmentMap.put(
-          "segment" + i,
+      segments.add(
           new DataSegment(
               "datasource" + i,
               new Interval(DateTimes.of("2012-01-01"), (DateTimes.of("2012-01-01")).plusHours(1)),
@@ -120,9 +120,9 @@ public void bigProfiler()
       EasyMock.expect(server.getName()).andReturn(Integer.toString(i)).atLeastOnce();
       EasyMock.expect(server.getHost()).andReturn(Integer.toString(i)).anyTimes();
       if (i == 0) {
-        EasyMock.expect(server.getSegments()).andReturn(segmentMap).anyTimes();
+        EasyMock.expect(server.getSegments()).andReturn(segments).anyTimes();
       } else {
-        EasyMock.expect(server.getSegments()).andReturn(new HashMap<String, DataSegment>()).anyTimes();
+        EasyMock.expect(server.getSegments()).andReturn(Collections.emptyList()).anyTimes();
       }
       EasyMock.expect(server.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
       EasyMock.replay(server);
@@ -152,7 +152,7 @@ public void bigProfiler()
                                 .withLoadManagementPeons(
                                     peonMap
                                 )
-                                .withAvailableSegments(segmentMap.values())
+                                .withAvailableSegments(segments)
                                 .withDynamicConfigs(
                                     CoordinatorDynamicConfig.builder().withMaxSegmentsToMove(
                                         MAX_SEGMENTS_TO_MOVE
@@ -209,7 +209,7 @@ public void profileRun()
     EasyMock.expect(druidServer2.getTier()).andReturn("normal").anyTimes();
     EasyMock.expect(druidServer2.getCurrSize()).andReturn(0L).atLeastOnce();
     EasyMock.expect(druidServer2.getMaxSize()).andReturn(100L).atLeastOnce();
-    EasyMock.expect(druidServer2.getSegments()).andReturn(new HashMap<String, DataSegment>()).anyTimes();
+    EasyMock.expect(druidServer2.getSegments()).andReturn(Collections.emptyList()).anyTimes();
     EasyMock.expect(druidServer2.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
     EasyMock.replay(druidServer2);
 
@@ -250,7 +250,7 @@ public void profileRun()
                                         toPeon
                                     )
                                 )
-                                .withAvailableSegments(segments.values())
+                                .withAvailableSegments(segments)
                                 .withDynamicConfigs(
                                     CoordinatorDynamicConfig.builder().withMaxSegmentsToMove(
                                         MAX_SEGMENTS_TO_MOVE
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerTest.java
index 053fedb82531..4acafeff99e7 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerTest.java
@@ -38,10 +38,9 @@
 import org.junit.Before;
 import org.junit.Test;
 
+import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.TreeSet;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -68,7 +67,7 @@ public class DruidCoordinatorBalancerTest
   private DataSegment segment2;
   private DataSegment segment3;
   private DataSegment segment4;
-  private Map<String, DataSegment> segments;
+  private List<DataSegment> segments;
   private ListeningExecutorService balancerStrategyExecutor;
   private BalancerStrategy balancerStrategy;
 
@@ -133,11 +132,11 @@ public void setUp()
         8L
     );
 
-    segments = new HashMap<>();
-    segments.put("datasource1_2012-01-01T00:00:00.000Z_2012-01-01T01:00:00.000Z_2012-03-01T00:00:00.000Z", segment1);
-    segments.put("datasource1_2012-02-01T00:00:00.000Z_2012-02-01T01:00:00.000Z_2012-03-01T00:00:00.000Z", segment2);
-    segments.put("datasource2_2012-01-01T00:00:00.000Z_2012-01-01T01:00:00.000Z_2012-03-01T00:00:00.000Z", segment3);
-    segments.put("datasource2_2012-02-01T00:00:00.000Z_2012-02-01T01:00:00.000Z_2012-03-01T00:00:00.000Z", segment4);
+    segments = new ArrayList<>();
+    segments.add(segment1);
+    segments.add(segment2);
+    segments.add(segment3);
+    segments.add(segment4);
 
     peon1 = new LoadQueuePeonTester();
     peon2 = new LoadQueuePeonTester();
@@ -166,7 +165,7 @@ public void tearDown()
   public void testMoveToEmptyServerBalancer()
   {
     mockDruidServer(druidServer1, "1", "normal", 30L, 100L, segments);
-    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyMap());
+    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyList());
 
     EasyMock.replay(druidServer3);
     EasyMock.replay(druidServer4);
@@ -199,7 +198,7 @@ public void testMoveToEmptyServerBalancer()
   public void testMoveMaxLoadQueueServerBalancer()
   {
     mockDruidServer(druidServer1, "1", "normal", 30L, 100L, segments);
-    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyMap());
+    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyList());
 
     EasyMock.replay(druidServer3);
     EasyMock.replay(druidServer4);
@@ -241,7 +240,7 @@ public void testMoveMaxLoadQueueServerBalancer()
   public void testMoveSameSegmentTwice()
   {
     mockDruidServer(druidServer1, "1", "normal", 30L, 100L, segments);
-    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyMap());
+    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyList());
 
     EasyMock.replay(druidServer3);
     EasyMock.replay(druidServer4);
@@ -277,7 +276,7 @@ public void testRun1()
   {
     // Mock some servers of different usages
     mockDruidServer(druidServer1, "1", "normal", 30L, 100L, segments);
-    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyMap());
+    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyList());
 
     EasyMock.replay(druidServer3);
     EasyMock.replay(druidServer4);
@@ -299,9 +298,9 @@ public void testRun2()
   {
     // Mock some servers of different usages
     mockDruidServer(druidServer1, "1", "normal", 30L, 100L, segments);
-    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyMap());
-    mockDruidServer(druidServer3, "3", "normal", 0L, 100L, Collections.emptyMap());
-    mockDruidServer(druidServer4, "4", "normal", 0L, 100L, Collections.emptyMap());
+    mockDruidServer(druidServer2, "2", "normal", 0L, 100L, Collections.emptyList());
+    mockDruidServer(druidServer3, "3", "normal", 0L, 100L, Collections.emptyList());
+    mockDruidServer(druidServer4, "4", "normal", 0L, 100L, Collections.emptyList());
 
     // Mock stuff that the coordinator needs
     mockCoordinator(coordinator);
@@ -341,7 +340,7 @@ private DruidCoordinatorRuntimeParams.Builder defaultRuntimeParamsBuilder(
                 .boxed()
                 .collect(Collectors.toMap(i -> String.valueOf(i + 1), peons::get))
         )
-        .withAvailableSegments(segments.values())
+        .withAvailableSegments(segments)
         .withDynamicConfigs(
             CoordinatorDynamicConfig.builder().withMaxSegmentsToMove(
                 MAX_SEGMENTS_TO_MOVE
@@ -357,7 +356,7 @@ private void mockDruidServer(
       String tier,
       long currentSize,
       long maxSize,
-      Map<String, DataSegment> segments
+      List<DataSegment> segments
   )
   {
     EasyMock.expect(druidServer.getName()).andReturn(name).anyTimes();
@@ -366,8 +365,8 @@ private void mockDruidServer(
     EasyMock.expect(druidServer.getMaxSize()).andReturn(maxSize).atLeastOnce();
     EasyMock.expect(druidServer.getSegments()).andReturn(segments).anyTimes();
     if (!segments.isEmpty()) {
-      segments.values().forEach(
-          s -> EasyMock.expect(druidServer.getSegment(s.getIdentifier())).andReturn(s).anyTimes()
+      segments.forEach(
+          s -> EasyMock.expect(druidServer.getSegment(s.getId())).andReturn(s).anyTimes()
       );
     } else {
       EasyMock.expect(druidServer.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerTester.java b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerTester.java
index 06dafbd7f9cf..3a96d4b2e7f1 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerTester.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorBalancerTester.java
@@ -23,6 +23,7 @@
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.server.coordinator.helper.DruidCoordinatorBalancer;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 
 public class DruidCoordinatorBalancerTester extends DruidCoordinatorBalancer
 {
@@ -43,35 +44,29 @@ protected void moveSegment(
 
     final String fromServerName = segment.getFromServer().getName();
     final DataSegment segmentToMove = segment.getSegment();
-    final String segmentName = segmentToMove.getIdentifier();
+    final SegmentId segmentId = segmentToMove.getId();
 
     if (!toPeon.getSegmentsToLoad().contains(segmentToMove) &&
-        (toServer.getSegment(segmentName) == null) &&
+        (toServer.getSegment(segmentId) == null) &&
         new ServerHolder(toServer, toPeon).getAvailableSize() > segmentToMove.getSize()) {
       log.info(
           "Moving [%s] from [%s] to [%s]",
-          segmentName,
+          segmentId,
           fromServerName,
           toServerName
       );
       try {
         final LoadQueuePeon loadPeon = params.getLoadManagementPeons().get(toServerName);
 
-        loadPeon.loadSegment(segment.getSegment(), new LoadPeonCallback()
-        {
-          @Override
-          public void execute()
-          {
-          }
-        });
+        loadPeon.loadSegment(segment.getSegment(), () -> {});
 
         final LoadQueuePeon dropPeon = params.getLoadManagementPeons().get(fromServerName);
         dropPeon.markSegmentToDrop(segment.getSegment());
 
-        currentlyMovingSegments.get("normal").put(segmentName, segment);
+        currentlyMovingSegments.get("normal").put(segmentId, segment);
       }
       catch (Exception e) {
-        log.info(e, StringUtils.format("[%s] : Moving exception", segmentName));
+        log.info(e, StringUtils.format("[%s] : Moving exception", segmentId));
       }
     }
   }
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorTest.java b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorTest.java
index bfe308cbd609..d1c84fcf50fb 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/DruidCoordinatorTest.java
@@ -56,6 +56,7 @@
 import org.apache.curator.framework.recipes.cache.PathChildrenCacheEvent;
 import org.apache.curator.framework.recipes.cache.PathChildrenCacheListener;
 import org.apache.curator.utils.ZKPaths;
+import org.apache.druid.timeline.SegmentId;
 import org.easymock.Capture;
 import org.easymock.EasyMock;
 import org.joda.time.Duration;
@@ -228,7 +229,7 @@ public void tearDown() throws Exception
   public void testMoveSegment()
   {
     segment = EasyMock.createNiceMock(DataSegment.class);
-    EasyMock.expect(segment.getIdentifier()).andReturn("dummySegment");
+    EasyMock.expect(segment.getId()).andReturn(SegmentId.dummy("dummySegment"));
     EasyMock.expect(segment.getDataSource()).andReturn("dummyDataSource");
     EasyMock.replay(segment);
 
@@ -248,30 +249,34 @@ public void testMoveSegment()
     EasyMock.replay(loadQueuePeon);
 
     ImmutableDruidDataSource druidDataSource = EasyMock.createNiceMock(ImmutableDruidDataSource.class);
-    EasyMock.expect(druidDataSource.getSegment(EasyMock.anyString())).andReturn(segment);
+    EasyMock.expect(druidDataSource.getSegment(EasyMock.anyObject(SegmentId.class))).andReturn(segment);
     EasyMock.replay(druidDataSource);
-    EasyMock.expect(databaseSegmentManager.getInventoryValue(EasyMock.anyString())).andReturn(druidDataSource);
+    EasyMock.expect(databaseSegmentManager.getDataSource(EasyMock.anyString())).andReturn(druidDataSource);
     EasyMock.replay(databaseSegmentManager);
     scheduledExecutorFactory = EasyMock.createNiceMock(ScheduledExecutorFactory.class);
     EasyMock.replay(scheduledExecutorFactory);
     EasyMock.replay(metadataRuleManager);
+    ImmutableDruidDataSource dataSource = EasyMock.createMock(ImmutableDruidDataSource.class);
+    EasyMock.expect(dataSource.getSegments()).andReturn(Collections.singletonList(segment)).anyTimes();
+    EasyMock.replay(dataSource);
     EasyMock.expect(druidServer.toImmutableDruidServer()).andReturn(
         new ImmutableDruidServer(
             new DruidServerMetadata("from", null, null, 5L, ServerType.HISTORICAL, null, 0),
             1L,
-            null,
-            ImmutableMap.of("dummySegment", segment)
+            ImmutableMap.of("dummyDataSource", dataSource),
+            1
         )
     ).atLeastOnce();
     EasyMock.replay(druidServer);
 
     druidServer2 = EasyMock.createMock(DruidServer.class);
+
     EasyMock.expect(druidServer2.toImmutableDruidServer()).andReturn(
         new ImmutableDruidServer(
             new DruidServerMetadata("to", null, null, 5L, ServerType.HISTORICAL, null, 0),
             1L,
-            null,
-            ImmutableMap.of("dummySegment2", segment)
+            ImmutableMap.of("dummyDataSource", dataSource),
+            1
         )
     ).atLeastOnce();
     EasyMock.replay(druidServer2);
@@ -336,7 +341,7 @@ public void testCoordinatorRun() throws Exception
     druidDataSources[0].addSegment(dataSegment);
 
     EasyMock.expect(databaseSegmentManager.isStarted()).andReturn(true).anyTimes();
-    EasyMock.expect(databaseSegmentManager.getInventory()).andReturn(
+    EasyMock.expect(databaseSegmentManager.getDataSources()).andReturn(
         ImmutableList.of(druidDataSources[0].toImmutableDruidDataSource())
     ).atLeastOnce();
     EasyMock.replay(databaseSegmentManager);
@@ -393,7 +398,7 @@ public void childEvent(
     coordinatorRunLatch.await();
 
     Assert.assertEquals(ImmutableMap.of(dataSource, 100.0), coordinator.getLoadStatus());
-    curator.delete().guaranteed().forPath(ZKPaths.makePath(LOADPATH, dataSegment.getIdentifier()));
+    curator.delete().guaranteed().forPath(ZKPaths.makePath(LOADPATH, dataSegment.getId().toString()));
 
     Map segmentAvailability = coordinator.getSegmentAvailability();
     Assert.assertEquals(1, segmentAvailability.size());
@@ -463,7 +468,7 @@ public void testCoordinatorTieredRun() throws Exception
     EasyMock.expect(metadataRuleManager.getRulesWithDefault(EasyMock.anyString()))
             .andReturn(ImmutableList.of(hotTier, coldTier)).atLeastOnce();
     EasyMock.expect(databaseSegmentManager.isStarted()).andReturn(true).anyTimes();
-    EasyMock.expect(databaseSegmentManager.getInventory()).andReturn(
+    EasyMock.expect(databaseSegmentManager.getDataSources()).andReturn(
         ImmutableList.of(druidDataSources[0].toImmutableDruidDataSource())
     ).atLeastOnce();
     EasyMock.expect(serverInventoryView.getInventory())
@@ -556,7 +561,7 @@ public void testOrderedAvailableDataSegments()
       dataSource.addSegment(segment);
     }
 
-    EasyMock.expect(databaseSegmentManager.getInventory()).andReturn(
+    EasyMock.expect(databaseSegmentManager.getDataSources()).andReturn(
         ImmutableList.of(dataSource.toImmutableDruidDataSource())
     ).atLeastOnce();
     EasyMock.replay(databaseSegmentManager);
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/HttpLoadQueuePeonTest.java b/server/src/test/java/org/apache/druid/server/coordinator/HttpLoadQueuePeonTest.java
index 6b65fae290bc..a14ed9ee439c 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/HttpLoadQueuePeonTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/HttpLoadQueuePeonTest.java
@@ -36,6 +36,7 @@
 import org.apache.druid.server.coordination.DataSegmentChangeRequest;
 import org.apache.druid.server.coordination.SegmentLoadDropHandler;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.jboss.netty.buffer.ChannelBuffers;
 import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
 import org.jboss.netty.handler.codec.http.HttpResponse;
@@ -115,22 +116,22 @@ public void testSimple() throws Exception
 
     httpLoadQueuePeon.start();
 
-    Map<String, CountDownLatch> latches = ImmutableMap.of(
-        segment1.getIdentifier(), new CountDownLatch(1),
-        segment2.getIdentifier(), new CountDownLatch(1),
-        segment3.getIdentifier(), new CountDownLatch(1),
-        segment4.getIdentifier(), new CountDownLatch(1)
+    Map<SegmentId, CountDownLatch> latches = ImmutableMap.of(
+        segment1.getId(), new CountDownLatch(1),
+        segment2.getId(), new CountDownLatch(1),
+        segment3.getId(), new CountDownLatch(1),
+        segment4.getId(), new CountDownLatch(1)
     );
 
-    httpLoadQueuePeon.dropSegment(segment1, () -> latches.get(segment1.getIdentifier()).countDown());
-    httpLoadQueuePeon.loadSegment(segment2, () -> latches.get(segment2.getIdentifier()).countDown());
-    httpLoadQueuePeon.dropSegment(segment3, () -> latches.get(segment3.getIdentifier()).countDown());
-    httpLoadQueuePeon.loadSegment(segment4, () -> latches.get(segment4.getIdentifier()).countDown());
+    httpLoadQueuePeon.dropSegment(segment1, () -> latches.get(segment1.getId()).countDown());
+    httpLoadQueuePeon.loadSegment(segment2, () -> latches.get(segment2.getId()).countDown());
+    httpLoadQueuePeon.dropSegment(segment3, () -> latches.get(segment3.getId()).countDown());
+    httpLoadQueuePeon.loadSegment(segment4, () -> latches.get(segment4.getId()).countDown());
 
-    latches.get(segment1.getIdentifier()).await();
-    latches.get(segment2.getIdentifier()).await();
-    latches.get(segment3.getIdentifier()).await();
-    latches.get(segment4.getIdentifier()).await();
+    latches.get(segment1.getId()).await();
+    latches.get(segment2.getId()).await();
+    latches.get(segment3.getId()).await();
+    latches.get(segment4.getId()).await();
 
     httpLoadQueuePeon.stop();
   }
@@ -152,22 +153,22 @@ public void testLoadDropAfterStop() throws Exception
 
     httpLoadQueuePeon.start();
 
-    Map<String, CountDownLatch> latches = ImmutableMap.of(
-        segment1.getIdentifier(), new CountDownLatch(1),
-        segment2.getIdentifier(), new CountDownLatch(1),
-        segment3.getIdentifier(), new CountDownLatch(1),
-        segment4.getIdentifier(), new CountDownLatch(1)
+    Map<SegmentId, CountDownLatch> latches = ImmutableMap.of(
+        segment1.getId(), new CountDownLatch(1),
+        segment2.getId(), new CountDownLatch(1),
+        segment3.getId(), new CountDownLatch(1),
+        segment4.getId(), new CountDownLatch(1)
     );
 
-    httpLoadQueuePeon.dropSegment(segment1, () -> latches.get(segment1.getIdentifier()).countDown());
-    httpLoadQueuePeon.loadSegment(segment2, () -> latches.get(segment2.getIdentifier()).countDown());
-    latches.get(segment1.getIdentifier()).await();
-    latches.get(segment2.getIdentifier()).await();
+    httpLoadQueuePeon.dropSegment(segment1, () -> latches.get(segment1.getId()).countDown());
+    httpLoadQueuePeon.loadSegment(segment2, () -> latches.get(segment2.getId()).countDown());
+    latches.get(segment1.getId()).await();
+    latches.get(segment2.getId()).await();
     httpLoadQueuePeon.stop();
-    httpLoadQueuePeon.dropSegment(segment3, () -> latches.get(segment3.getIdentifier()).countDown());
-    httpLoadQueuePeon.loadSegment(segment4, () -> latches.get(segment4.getIdentifier()).countDown());
-    latches.get(segment3.getIdentifier()).await();
-    latches.get(segment4.getIdentifier()).await();
+    httpLoadQueuePeon.dropSegment(segment3, () -> latches.get(segment3.getId()).countDown());
+    httpLoadQueuePeon.loadSegment(segment4, () -> latches.get(segment4.getId()).countDown());
+    latches.get(segment3.getId()).await();
+    latches.get(segment4.getId()).await();
 
   }
 
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/LoadQueuePeonTest.java b/server/src/test/java/org/apache/druid/server/coordinator/LoadQueuePeonTest.java
index 496cd959a933..286c2d0d95f6 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/LoadQueuePeonTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/LoadQueuePeonTest.java
@@ -194,7 +194,8 @@ public void childEvent(
 
     for (DataSegment segment : segmentToDrop) {
       loadQueuePeon.dropSegment(
-          segment, new LoadPeonCallback()
+          segment,
+          new LoadPeonCallback()
           {
             @Override
             public void execute()
@@ -207,7 +208,8 @@ public void execute()
 
     for (DataSegment segment : segmentToLoad) {
       loadQueuePeon.loadSegment(
-          segment, new LoadPeonCallback()
+          segment,
+          new LoadPeonCallback()
           {
             @Override
             public void execute()
@@ -223,7 +225,7 @@ public void execute()
     Assert.assertEquals(5, loadQueuePeon.getSegmentsToDrop().size());
 
     for (DataSegment segment : segmentToDrop) {
-      String dropRequestPath = ZKPaths.makePath(LOAD_QUEUE_PATH, segment.getIdentifier());
+      String dropRequestPath = ZKPaths.makePath(LOAD_QUEUE_PATH, segment.getId().toString());
       Assert.assertTrue(timing.forWaiting().awaitLatch(dropRequestSignal[requestSignalIdx.get()]));
       Assert.assertNotNull(curator.checkExists().forPath(dropRequestPath));
       Assert.assertEquals(
@@ -256,7 +258,7 @@ public void execute()
     }
 
     for (DataSegment segment : expectedLoadOrder) {
-      String loadRequestPath = ZKPaths.makePath(LOAD_QUEUE_PATH, segment.getIdentifier());
+      String loadRequestPath = ZKPaths.makePath(LOAD_QUEUE_PATH, segment.getId().toString());
       Assert.assertTrue(timing.forWaiting().awaitLatch(loadRequestSignal[requestSignalIdx.get()]));
       Assert.assertNotNull(curator.checkExists().forPath(loadRequestPath));
       Assert.assertEquals(
@@ -318,7 +320,8 @@ public void childEvent(
     loadQueueCache.start();
 
     loadQueuePeon.loadSegment(
-        segment, new LoadPeonCallback()
+        segment,
+        new LoadPeonCallback()
         {
           @Override
           public void execute()
@@ -328,7 +331,7 @@ public void execute()
         }
     );
 
-    String loadRequestPath = ZKPaths.makePath(LOAD_QUEUE_PATH, segment.getIdentifier());
+    String loadRequestPath = ZKPaths.makePath(LOAD_QUEUE_PATH, segment.getId().toString());
     Assert.assertTrue(timing.forWaiting().awaitLatch(loadRequestSignal));
     Assert.assertNotNull(curator.checkExists().forPath(loadRequestPath));
     Assert.assertEquals(
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/ReservoirSegmentSamplerTest.java b/server/src/test/java/org/apache/druid/server/coordinator/ReservoirSegmentSamplerTest.java
index 323104bde46a..3d44d6884846 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/ReservoirSegmentSamplerTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/ReservoirSegmentSamplerTest.java
@@ -19,7 +19,6 @@
 
 package org.apache.druid.server.coordinator;
 
-import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import org.apache.druid.client.ImmutableDruidServer;
@@ -33,6 +32,7 @@
 import org.junit.Before;
 import org.junit.Test;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -52,10 +52,10 @@ public class ReservoirSegmentSamplerTest
   private DataSegment segment2;
   private DataSegment segment3;
   private DataSegment segment4;
-  Map<String, DataSegment> segmentsMap1;
-  Map<String, DataSegment> segmentsMap2;
-  Map<String, DataSegment> segmentsMap3;
-  Map<String, DataSegment> segmentsMap4;
+  List<DataSegment> segments1;
+  List<DataSegment> segments2;
+  List<DataSegment> segments3;
+  List<DataSegment> segments4;
   List<DataSegment> segments;
 
   @Before
@@ -124,22 +124,10 @@ public void setUp()
 
     segments = Lists.newArrayList(segment1, segment2, segment3, segment4);
 
-    segmentsMap1 = ImmutableMap.of(
-        "datasource1_2012-01-01T00:00:00.000Z_2012-01-01T01:00:00.000Z_2012-03-01T00:00:00.000Z",
-        segment1
-    );
-    segmentsMap2 = ImmutableMap.of(
-        "datasource1_2012-02-01T00:00:00.000Z_2012-02-01T01:00:00.000Z_2012-03-01T00:00:00.000Z",
-        segment2
-    );
-    segmentsMap3 = ImmutableMap.of(
-        "datasource2_2012-01-01T00:00:00.000Z_2012-01-01T01:00:00.000Z_2012-03-01T00:00:00.000Z",
-        segment3
-    );
-    segmentsMap4 = ImmutableMap.of(
-        "datasource2_2012-02-01T00:00:00.000Z_2012-02-01T01:00:00.000Z_2012-03-01T00:00:00.000Z",
-        segment4
-    );
+    segments1 = Collections.singletonList(segment1);
+    segments2 = Collections.singletonList(segment2);
+    segments3 = Collections.singletonList(segment3);
+    segments4 = Collections.singletonList(segment4);
   }
 
   //checks if every segment is selected at least once out of 5000 trials
@@ -149,7 +137,7 @@ public void getRandomBalancerSegmentHolderTest()
     EasyMock.expect(druidServer1.getName()).andReturn("1").atLeastOnce();
     EasyMock.expect(druidServer1.getCurrSize()).andReturn(30L).atLeastOnce();
     EasyMock.expect(druidServer1.getMaxSize()).andReturn(100L).atLeastOnce();
-    EasyMock.expect(druidServer1.getSegments()).andReturn(segmentsMap1).anyTimes();
+    EasyMock.expect(druidServer1.getSegments()).andReturn(segments1).anyTimes();
     EasyMock.expect(druidServer1.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
     EasyMock.replay(druidServer1);
 
@@ -157,7 +145,7 @@ public void getRandomBalancerSegmentHolderTest()
     EasyMock.expect(druidServer2.getTier()).andReturn("normal").anyTimes();
     EasyMock.expect(druidServer2.getCurrSize()).andReturn(30L).atLeastOnce();
     EasyMock.expect(druidServer2.getMaxSize()).andReturn(100L).atLeastOnce();
-    EasyMock.expect(druidServer2.getSegments()).andReturn(segmentsMap2).anyTimes();
+    EasyMock.expect(druidServer2.getSegments()).andReturn(segments2).anyTimes();
     EasyMock.expect(druidServer2.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
     EasyMock.replay(druidServer2);
 
@@ -165,7 +153,7 @@ public void getRandomBalancerSegmentHolderTest()
     EasyMock.expect(druidServer3.getTier()).andReturn("normal").anyTimes();
     EasyMock.expect(druidServer3.getCurrSize()).andReturn(30L).atLeastOnce();
     EasyMock.expect(druidServer3.getMaxSize()).andReturn(100L).atLeastOnce();
-    EasyMock.expect(druidServer3.getSegments()).andReturn(segmentsMap3).anyTimes();
+    EasyMock.expect(druidServer3.getSegments()).andReturn(segments3).anyTimes();
     EasyMock.expect(druidServer3.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
     EasyMock.replay(druidServer3);
 
@@ -173,7 +161,7 @@ public void getRandomBalancerSegmentHolderTest()
     EasyMock.expect(druidServer4.getTier()).andReturn("normal").anyTimes();
     EasyMock.expect(druidServer4.getCurrSize()).andReturn(30L).atLeastOnce();
     EasyMock.expect(druidServer4.getMaxSize()).andReturn(100L).atLeastOnce();
-    EasyMock.expect(druidServer4.getSegments()).andReturn(segmentsMap4).anyTimes();
+    EasyMock.expect(druidServer4.getSegments()).andReturn(segments4).anyTimes();
     EasyMock.expect(druidServer4.getSegment(EasyMock.anyObject())).andReturn(null).anyTimes();
     EasyMock.replay(druidServer4);
 
@@ -202,7 +190,5 @@ public void getRandomBalancerSegmentHolderTest()
     for (DataSegment segment : segments) {
       Assert.assertEquals(segmentCountMap.get(segment), new Integer(1));
     }
-
-
   }
 }
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/ServerHolderTest.java b/server/src/test/java/org/apache/druid/server/coordinator/ServerHolderTest.java
index 93996f0dc1e8..68fca426406c 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/ServerHolderTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/ServerHolderTest.java
@@ -34,7 +34,6 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.TreeMap;
 
 public class ServerHolderTest
 {
@@ -64,18 +63,8 @@ public class ServerHolderTest
   );
 
   private static final Map<String, ImmutableDruidDataSource> dataSources = ImmutableMap.of(
-      "src1",
-      new ImmutableDruidDataSource(
-          "src1",
-          Collections.emptyMap(),
-          new TreeMap<>()
-      ),
-      "src2",
-      new ImmutableDruidDataSource(
-          "src2",
-          Collections.emptyMap(),
-          new TreeMap<>()
-      )
+      "src1", new ImmutableDruidDataSource("src1", Collections.emptyMap(), Collections.singletonList(segments.get(0))),
+      "src2", new ImmutableDruidDataSource("src2", Collections.emptyMap(), Collections.singletonList(segments.get(1)))
   );
 
   @Test
@@ -86,14 +75,8 @@ public void testCompareTo()
         new ImmutableDruidServer(
             new DruidServerMetadata("name1", "host1", null, 100L, ServerType.HISTORICAL, "tier1", 0),
             0L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
@@ -103,14 +86,8 @@ public void testCompareTo()
         new ImmutableDruidServer(
             new DruidServerMetadata("name1", "host1", null, 200L, ServerType.HISTORICAL, "tier1", 0),
             100L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
@@ -120,14 +97,8 @@ public void testCompareTo()
         new ImmutableDruidServer(
             new DruidServerMetadata("name1", "host1", null, 1000L, ServerType.HISTORICAL, "tier1", 0),
             990L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
@@ -137,14 +108,8 @@ public void testCompareTo()
         new ImmutableDruidServer(
             new DruidServerMetadata("name1", "host1", null, 50L, ServerType.HISTORICAL, "tier1", 0),
             0L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
@@ -161,14 +126,8 @@ public void testEquals()
         new ImmutableDruidServer(
             new DruidServerMetadata("name1", "host1", null, 100L, ServerType.HISTORICAL, "tier1", 0),
             0L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
@@ -177,14 +136,8 @@ public void testEquals()
         new ImmutableDruidServer(
             new DruidServerMetadata("name2", "host1", null, 200L, ServerType.HISTORICAL, "tier1", 0),
             100L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
@@ -193,14 +146,8 @@ public void testEquals()
         new ImmutableDruidServer(
             new DruidServerMetadata("name1", "host2", null, 200L, ServerType.HISTORICAL, "tier1", 0),
             100L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
@@ -209,14 +156,8 @@ public void testEquals()
         new ImmutableDruidServer(
             new DruidServerMetadata("name1", "host1", null, 200L, ServerType.HISTORICAL, "tier2", 0),
             100L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
@@ -225,14 +166,8 @@ public void testEquals()
         new ImmutableDruidServer(
             new DruidServerMetadata("name1", "host1", null, 100L, ServerType.REALTIME, "tier1", 0),
             0L,
-            ImmutableMap.of(
-                "src1",
-                dataSources.get("src1")
-            ),
-            ImmutableMap.of(
-                "segment1",
-                segments.get(0)
-            )
+            ImmutableMap.of("src1", dataSources.get("src1")),
+            1
         ),
         new LoadQueuePeonTester()
     );
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/cost/CachingCostBalancerStrategyTest.java b/server/src/test/java/org/apache/druid/server/coordinator/cost/CachingCostBalancerStrategyTest.java
index 8781cf0dc957..fe7b321777e9 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/cost/CachingCostBalancerStrategyTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/cost/CachingCostBalancerStrategyTest.java
@@ -115,9 +115,7 @@ private CachingCostBalancerStrategy createCachingCostBalancerStrategy(
   {
     ClusterCostCache.Builder builder = ClusterCostCache.builder();
     serverHolders.forEach(
-        s -> s.getServer().getSegments().values().forEach(
-            segment -> builder.addSegment(s.getServer().getName(), segment)
-        )
+        s -> s.getServer().getSegments().forEach(segment -> builder.addSegment(s.getServer().getName(), segment))
     );
     return new CachingCostBalancerStrategy(builder.build(), listeningExecutorService);
   }
diff --git a/server/src/test/java/org/apache/druid/server/coordinator/rules/LoadRuleTest.java b/server/src/test/java/org/apache/druid/server/coordinator/rules/LoadRuleTest.java
index 86c1b73d5a2c..0d99c25fe29c 100644
--- a/server/src/test/java/org/apache/druid/server/coordinator/rules/LoadRuleTest.java
+++ b/server/src/test/java/org/apache/druid/server/coordinator/rules/LoadRuleTest.java
@@ -128,7 +128,7 @@ public void testLoad()
 
     final DataSegment segment = createDataSegment("foo");
 
-    throttler.registerReplicantCreation(DruidServer.DEFAULT_TIER, segment.getIdentifier(), "hostNorm");
+    throttler.registerReplicantCreation(DruidServer.DEFAULT_TIER, segment.getId(), "hostNorm");
     EasyMock.expectLastCall().once();
 
     EasyMock.expect(mockBalancerStrategy.findNewSegmentHomeReplicator(EasyMock.anyObject(), EasyMock.anyObject()))
diff --git a/server/src/test/java/org/apache/druid/server/http/DatasourcesResourceTest.java b/server/src/test/java/org/apache/druid/server/http/DataSourcesResourceTest.java
similarity index 88%
rename from server/src/test/java/org/apache/druid/server/http/DatasourcesResourceTest.java
rename to server/src/test/java/org/apache/druid/server/http/DataSourcesResourceTest.java
index da95b0baa58c..bd80611bc562 100644
--- a/server/src/test/java/org/apache/druid/server/http/DatasourcesResourceTest.java
+++ b/server/src/test/java/org/apache/druid/server/http/DataSourcesResourceTest.java
@@ -37,6 +37,7 @@
 import org.apache.druid.server.security.AuthorizerMapper;
 import org.apache.druid.server.security.Resource;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.easymock.EasyMock;
 import org.joda.time.Interval;
 import org.junit.Assert;
@@ -55,7 +56,7 @@
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 
-public class DatasourcesResourceTest
+public class DataSourcesResourceTest
 {
   private CoordinatorServerView inventoryView;
   private DruidServer server;
@@ -74,7 +75,7 @@ public void setUp()
         new DataSegment(
             "datasource1",
             Intervals.of("2010-01-01/P1D"),
-            null,
+            "",
             null,
             null,
             null,
@@ -87,7 +88,7 @@ public void setUp()
         new DataSegment(
             "datasource1",
             Intervals.of("2010-01-22/P1D"),
-            null,
+            "",
             null,
             null,
             null,
@@ -100,7 +101,7 @@ public void setUp()
         new DataSegment(
             "datasource2",
             Intervals.of("2010-01-01/P1D"),
-            null,
+            "",
             null,
             null,
             null,
@@ -152,7 +153,7 @@ public void testGetFullQueryableDataSources()
     EasyMock.expectLastCall().times(1);
 
     EasyMock.replay(inventoryView, server, request);
-    DatasourcesResource datasourcesResource = new DatasourcesResource(
+    DataSourcesResource datasourcesResource = new DataSourcesResource(
         inventoryView,
         null,
         null,
@@ -236,7 +237,7 @@ public Access authorize(AuthenticationResult authenticationResult1, Resource res
       }
     };
 
-    DatasourcesResource datasourcesResource = new DatasourcesResource(
+    DataSourcesResource datasourcesResource = new DataSourcesResource(
         inventoryView,
         null,
         null,
@@ -268,19 +269,11 @@ public Access authorize(AuthenticationResult authenticationResult1, Resource res
   @Test
   public void testGetSimpleQueryableDataSources()
   {
-    EasyMock.expect(server.getDataSources()).andReturn(
-        listDataSources
-    ).atLeastOnce();
-    EasyMock.expect(server.getDataSource("datasource1")).andReturn(
-        listDataSources.get(0)
-    ).atLeastOnce();
+    EasyMock.expect(server.getDataSources()).andReturn(listDataSources).atLeastOnce();
+    EasyMock.expect(server.getDataSource("datasource1")).andReturn(listDataSources.get(0)).atLeastOnce();
     EasyMock.expect(server.getTier()).andReturn(null).atLeastOnce();
-    EasyMock.expect(server.getDataSource("datasource2")).andReturn(
-        listDataSources.get(1)
-    ).atLeastOnce();
-    EasyMock.expect(inventoryView.getInventory()).andReturn(
-        ImmutableList.of(server)
-    ).atLeastOnce();
+    EasyMock.expect(server.getDataSource("datasource2")).andReturn(listDataSources.get(1)).atLeastOnce();
+    EasyMock.expect(inventoryView.getInventory()).andReturn(ImmutableList.of(server)).atLeastOnce();
     EasyMock.expect(request.getAttribute(AuthConfig.DRUID_ALLOW_UNSECURED_PATH)).andReturn(null).once();
     EasyMock.expect(request.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED)).andReturn(null).once();
     EasyMock.expect(request.getAttribute(AuthConfig.DRUID_AUTHENTICATION_RESULT)).andReturn(
@@ -290,7 +283,7 @@ public void testGetSimpleQueryableDataSources()
     EasyMock.expectLastCall().times(1);
 
     EasyMock.replay(inventoryView, server, request);
-    DatasourcesResource datasourcesResource = new DatasourcesResource(
+    DataSourcesResource datasourcesResource = new DataSourcesResource(
         inventoryView,
         null,
         null,
@@ -315,15 +308,11 @@ public void testGetSimpleQueryableDataSources()
   public void testFullGetTheDataSource()
   {
     DruidDataSource dataSource1 = new DruidDataSource("datasource1", new HashMap<>());
-    EasyMock.expect(server.getDataSource("datasource1")).andReturn(
-        dataSource1
-    ).atLeastOnce();
-    EasyMock.expect(inventoryView.getInventory()).andReturn(
-        ImmutableList.of(server)
-    ).atLeastOnce();
+    EasyMock.expect(server.getDataSource("datasource1")).andReturn(dataSource1).atLeastOnce();
+    EasyMock.expect(inventoryView.getInventory()).andReturn(ImmutableList.of(server)).atLeastOnce();
 
     EasyMock.replay(inventoryView, server);
-    DatasourcesResource datasourcesResource = new DatasourcesResource(inventoryView, null, null, new AuthConfig(), null);
+    DataSourcesResource datasourcesResource = new DataSourcesResource(inventoryView, null, null, new AuthConfig(), null);
     Response response = datasourcesResource.getTheDataSource("datasource1", "full");
     ImmutableDruidDataSource result = (ImmutableDruidDataSource) response.getEntity();
     Assert.assertEquals(200, response.getStatus());
@@ -335,12 +324,10 @@ public void testFullGetTheDataSource()
   public void testNullGetTheDataSource()
   {
     EasyMock.expect(server.getDataSource("none")).andReturn(null).atLeastOnce();
-    EasyMock.expect(inventoryView.getInventory()).andReturn(
-        ImmutableList.of(server)
-    ).atLeastOnce();
+    EasyMock.expect(inventoryView.getInventory()).andReturn(ImmutableList.of(server)).atLeastOnce();
 
     EasyMock.replay(inventoryView, server);
-    DatasourcesResource datasourcesResource = new DatasourcesResource(inventoryView, null, null, new AuthConfig(), null);
+    DataSourcesResource datasourcesResource = new DataSourcesResource(inventoryView, null, null, new AuthConfig(), null);
     Assert.assertEquals(204, datasourcesResource.getTheDataSource("none", null).getStatus());
     EasyMock.verify(inventoryView, server);
   }
@@ -350,18 +337,14 @@ public void testSimpleGetTheDataSource()
   {
     DruidDataSource dataSource1 = new DruidDataSource("datasource1", new HashMap<>());
     dataSource1.addSegment(
-        new DataSegment("datasegment1", Intervals.of("2010-01-01/P1D"), null, null, null, null, null, 0x9, 10)
+        new DataSegment("datasegment1", Intervals.of("2010-01-01/P1D"), "", null, null, null, null, 0x9, 10)
     );
-    EasyMock.expect(server.getDataSource("datasource1")).andReturn(
-        dataSource1
-    ).atLeastOnce();
+    EasyMock.expect(server.getDataSource("datasource1")).andReturn(dataSource1).atLeastOnce();
     EasyMock.expect(server.getTier()).andReturn(null).atLeastOnce();
-    EasyMock.expect(inventoryView.getInventory()).andReturn(
-        ImmutableList.of(server)
-    ).atLeastOnce();
+    EasyMock.expect(inventoryView.getInventory()).andReturn(ImmutableList.of(server)).atLeastOnce();
 
     EasyMock.replay(inventoryView, server);
-    DatasourcesResource datasourcesResource = new DatasourcesResource(inventoryView, null, null, new AuthConfig(), null);
+    DataSourcesResource datasourcesResource = new DataSourcesResource(inventoryView, null, null, new AuthConfig(), null);
     Response response = datasourcesResource.getTheDataSource("datasource1", null);
     Assert.assertEquals(200, response.getStatus());
     Map<String, Map<String, Object>> result = (Map<String, Map<String, Object>>) response.getEntity();
@@ -400,7 +383,7 @@ public void testSimpleGetTheDataSourceManyTiers()
     ).atLeastOnce();
 
     EasyMock.replay(inventoryView, server, server2, server3);
-    DatasourcesResource datasourcesResource = new DatasourcesResource(inventoryView, null, null, new AuthConfig(), null);
+    DataSourcesResource datasourcesResource = new DataSourcesResource(inventoryView, null, null, new AuthConfig(), null);
     Response response = datasourcesResource.getTheDataSource("datasource1", null);
     Assert.assertEquals(200, response.getStatus());
     Map<String, Map<String, Object>> result = (Map<String, Map<String, Object>>) response.getEntity();
@@ -431,7 +414,7 @@ public void testGetSegmentDataSourceIntervals()
     List<Interval> expectedIntervals = new ArrayList<>();
     expectedIntervals.add(Intervals.of("2010-01-22T00:00:00.000Z/2010-01-23T00:00:00.000Z"));
     expectedIntervals.add(Intervals.of("2010-01-01T00:00:00.000Z/2010-01-02T00:00:00.000Z"));
-    DatasourcesResource datasourcesResource = new DatasourcesResource(inventoryView, null, null, new AuthConfig(), null);
+    DataSourcesResource datasourcesResource = new DataSourcesResource(inventoryView, null, null, new AuthConfig(), null);
 
     Response response = datasourcesResource.getSegmentDataSourceIntervals("invalidDataSource", null, null);
     Assert.assertEquals(response.getEntity(), null);
@@ -443,23 +426,21 @@ public void testGetSegmentDataSourceIntervals()
     Assert.assertEquals(expectedIntervals.get(1), actualIntervals.last());
 
     response = datasourcesResource.getSegmentDataSourceIntervals("datasource1", "simple", null);
-    TreeMap<Interval, Map<String, Object>> results = (TreeMap) response.getEntity();
+    TreeMap<Interval, Map<DataSourcesResource.SimpleProperties, Object>> results = (TreeMap) response.getEntity();
     Assert.assertEquals(2, results.size());
     Assert.assertEquals(expectedIntervals.get(0), results.firstKey());
     Assert.assertEquals(expectedIntervals.get(1), results.lastKey());
-    Assert.assertEquals(1, results.firstEntry().getValue().get("count"));
-    Assert.assertEquals(1, results.lastEntry().getValue().get("count"));
+    Assert.assertEquals(1, results.firstEntry().getValue().get(DataSourcesResource.SimpleProperties.count));
+    Assert.assertEquals(1, results.lastEntry().getValue().get(DataSourcesResource.SimpleProperties.count));
 
     response = datasourcesResource.getSegmentDataSourceIntervals("datasource1", null, "full");
-    results = ((TreeMap<Interval, Map<String, Object>>) response.getEntity());
+    Map<Interval, Map<SegmentId, Object>> results2 = ((Map<Interval, Map<SegmentId, Object>>) response.getEntity());
     int i = 1;
-    for (Map.Entry<Interval, Map<String, Object>> entry : results.entrySet()) {
+    for (Map.Entry<Interval, Map<SegmentId, Object>> entry : results2.entrySet()) {
       Assert.assertEquals(dataSegmentList.get(i).getInterval(), entry.getKey());
       Assert.assertEquals(
           dataSegmentList.get(i),
-          ((Map<String, Object>) entry.getValue().get(dataSegmentList.get(i).getIdentifier())).get(
-              "metadata"
-          )
+          ((Map<String, Object>) entry.getValue().get(dataSegmentList.get(i).getId())).get("metadata")
       );
       i--;
     }
@@ -473,12 +454,10 @@ public void testGetSegmentDataSourceSpecificInterval()
     server.addDataSegment(dataSegmentList.get(0));
     server.addDataSegment(dataSegmentList.get(1));
     server.addDataSegment(dataSegmentList.get(2));
-    EasyMock.expect(inventoryView.getInventory()).andReturn(
-        ImmutableList.of(server)
-    ).atLeastOnce();
+    EasyMock.expect(inventoryView.getInventory()).andReturn(ImmutableList.of(server)).atLeastOnce();
     EasyMock.replay(inventoryView);
 
-    DatasourcesResource datasourcesResource = new DatasourcesResource(inventoryView, null, null, new AuthConfig(), null);
+    DataSourcesResource datasourcesResource = new DataSourcesResource(inventoryView, null, null, new AuthConfig(), null);
     Response response = datasourcesResource.getSegmentDataSourceSpecificInterval(
         "invalidDataSource",
         "2010-01-01/P1D",
@@ -496,11 +475,11 @@ public void testGetSegmentDataSourceSpecificInterval()
     Assert.assertEquals(ImmutableSet.of(), response.getEntity());
 
     response = datasourcesResource.getSegmentDataSourceSpecificInterval("datasource1", "2010-01-01/P1D", null, null);
-    Assert.assertEquals(ImmutableSet.of(dataSegmentList.get(0).getIdentifier()), response.getEntity());
+    Assert.assertEquals(ImmutableSet.of(dataSegmentList.get(0).getId()), response.getEntity());
 
     response = datasourcesResource.getSegmentDataSourceSpecificInterval("datasource1", "2010-01-01/P1M", null, null);
     Assert.assertEquals(
-        ImmutableSet.of(dataSegmentList.get(1).getIdentifier(), dataSegmentList.get(0).getIdentifier()),
+        ImmutableSet.of(dataSegmentList.get(1).getId(), dataSegmentList.get(0).getId()),
         response.getEntity()
     );
 
@@ -510,24 +489,26 @@ public void testGetSegmentDataSourceSpecificInterval()
         "simple",
         null
     );
-    HashMap<Interval, Map<String, Object>> results = ((HashMap<Interval, Map<String, Object>>) response.getEntity());
+    Map<Interval, Map<DataSourcesResource.SimpleProperties, Object>> results =
+        ((Map<Interval, Map<DataSourcesResource.SimpleProperties, Object>>) response.getEntity());
     Assert.assertEquals(2, results.size());
     int i;
     for (i = 0; i < 2; i++) {
       Assert.assertTrue(results.containsKey(dataSegmentList.get(i).getInterval()));
-      Assert.assertEquals(1, (results.get(dataSegmentList.get(i).getInterval())).get("count"));
+      Assert.assertEquals(
+          1,
+          (results.get(dataSegmentList.get(i).getInterval())).get(DataSourcesResource.SimpleProperties.count)
+      );
     }
 
     response = datasourcesResource.getSegmentDataSourceSpecificInterval("datasource1", "2010-01-01/P1M", null, "full");
-    TreeMap<Interval, Map<String, Object>> results1 = ((TreeMap<Interval, Map<String, Object>>) response.getEntity());
+    Map<Interval, Map<SegmentId, Object>> results1 = ((Map<Interval, Map<SegmentId, Object>>) response.getEntity());
     i = 1;
-    for (Map.Entry<Interval, Map<String, Object>> entry : results1.entrySet()) {
+    for (Map.Entry<Interval, Map<SegmentId, Object>> entry : results1.entrySet()) {
       Assert.assertEquals(dataSegmentList.get(i).getInterval(), entry.getKey());
       Assert.assertEquals(
           dataSegmentList.get(i),
-          ((Map<String, Object>) entry.getValue().get(dataSegmentList.get(i).getIdentifier())).get(
-              "metadata"
-          )
+          ((Map<String, Object>) entry.getValue().get(dataSegmentList.get(i).getId())).get("metadata")
       );
       i--;
     }
@@ -545,7 +526,7 @@ public void testDeleteDataSourceSpecificInterval()
     EasyMock.expectLastCall().once();
     EasyMock.replay(indexingServiceClient, server);
 
-    DatasourcesResource datasourcesResource = new DatasourcesResource(
+    DataSourcesResource datasourcesResource = new DataSourcesResource(
         inventoryView,
         null,
         indexingServiceClient,
@@ -564,7 +545,7 @@ public void testDeleteDataSource()
   {
     IndexingServiceClient indexingServiceClient = EasyMock.createStrictMock(IndexingServiceClient.class);
     EasyMock.replay(indexingServiceClient, server);
-    DatasourcesResource datasourcesResource = new DatasourcesResource(
+    DataSourcesResource datasourcesResource = new DataSourcesResource(
         inventoryView,
         null,
         indexingServiceClient,
diff --git a/server/src/test/java/org/apache/druid/server/http/IntervalsResourceTest.java b/server/src/test/java/org/apache/druid/server/http/IntervalsResourceTest.java
index 790cde544c87..68137fa1814a 100644
--- a/server/src/test/java/org/apache/druid/server/http/IntervalsResourceTest.java
+++ b/server/src/test/java/org/apache/druid/server/http/IntervalsResourceTest.java
@@ -61,7 +61,7 @@ public void setUp()
         new DataSegment(
             "datasource1",
             Intervals.of("2010-01-01T00:00:00.000Z/P1D"),
-            null,
+            "",
             null,
             null,
             null,
@@ -74,7 +74,7 @@ public void setUp()
         new DataSegment(
             "datasource1",
             Intervals.of("2010-01-22T00:00:00.000Z/P1D"),
-            null,
+            "",
             null,
             null,
             null,
@@ -87,7 +87,7 @@ public void setUp()
         new DataSegment(
             "datasource2",
             Intervals.of("2010-01-01T00:00:00.000Z/P1D"),
-            null,
+            "",
             null,
             null,
             null,
diff --git a/server/src/test/java/org/apache/druid/server/http/security/SecurityResourceFilterTest.java b/server/src/test/java/org/apache/druid/server/http/security/SecurityResourceFilterTest.java
index be85f255cd72..9d7446db0a8c 100644
--- a/server/src/test/java/org/apache/druid/server/http/security/SecurityResourceFilterTest.java
+++ b/server/src/test/java/org/apache/druid/server/http/security/SecurityResourceFilterTest.java
@@ -30,7 +30,7 @@
 import org.apache.druid.server.http.BrokerResource;
 import org.apache.druid.server.http.CoordinatorDynamicConfigsResource;
 import org.apache.druid.server.http.CoordinatorResource;
-import org.apache.druid.server.http.DatasourcesResource;
+import org.apache.druid.server.http.DataSourcesResource;
 import org.apache.druid.server.http.HistoricalResource;
 import org.apache.druid.server.http.IntervalsResource;
 import org.apache.druid.server.http.MetadataResource;
@@ -56,7 +56,7 @@ public static Collection<Object[]> data()
     return ImmutableList.copyOf(
         Iterables.concat(
             getRequestPathsWithAuthorizer(CoordinatorResource.class),
-            getRequestPathsWithAuthorizer(DatasourcesResource.class),
+            getRequestPathsWithAuthorizer(DataSourcesResource.class),
             getRequestPathsWithAuthorizer(BrokerResource.class),
             getRequestPathsWithAuthorizer(HistoricalResource.class),
             getRequestPathsWithAuthorizer(IntervalsResource.class),
diff --git a/server/src/test/java/org/apache/druid/timeline/DataSegmentTest.java b/server/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
index 6eaf103995d1..ad7524988726 100644
--- a/server/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
+++ b/server/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
@@ -102,7 +102,7 @@ public void testV1Serialization() throws Exception
     Assert.assertEquals(segment.getMetrics(), deserializedSegment.getMetrics());
     Assert.assertEquals(segment.getShardSpec(), deserializedSegment.getShardSpec());
     Assert.assertEquals(segment.getSize(), deserializedSegment.getSize());
-    Assert.assertEquals(segment.getIdentifier(), deserializedSegment.getIdentifier());
+    Assert.assertEquals(segment.getId(), deserializedSegment.getId());
 
     deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
     Assert.assertEquals(0, segment.compareTo(deserializedSegment));
@@ -115,7 +115,7 @@ public void testV1Serialization() throws Exception
   }
 
   @Test
-  public void testIdentifier()
+  public void testId()
   {
     final DataSegment segment = DataSegment.builder()
                                            .dataSource("foo")
@@ -126,12 +126,12 @@ public void testIdentifier()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getIdentifier()
+        segment.getId()
     );
   }
 
   @Test
-  public void testIdentifierWithZeroPartition()
+  public void testIdWithZeroPartition()
   {
     final DataSegment segment = DataSegment.builder()
                                            .dataSource("foo")
@@ -142,12 +142,12 @@ public void testIdentifierWithZeroPartition()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getIdentifier()
+        segment.getId().toString()
     );
   }
 
   @Test
-  public void testIdentifierWithNonzeroPartition()
+  public void testIdWithNonzeroPartition()
   {
     final DataSegment segment = DataSegment.builder()
                                            .dataSource("foo")
@@ -158,7 +158,7 @@ public void testIdentifierWithNonzeroPartition()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z_1",
-        segment.getIdentifier()
+        segment.getId().toString()
     );
   }
 
diff --git a/services/src/main/java/org/apache/druid/cli/CliCoordinator.java b/services/src/main/java/org/apache/druid/cli/CliCoordinator.java
index 5503c85b84cb..e4de3bf66b87 100644
--- a/services/src/main/java/org/apache/druid/cli/CliCoordinator.java
+++ b/services/src/main/java/org/apache/druid/cli/CliCoordinator.java
@@ -71,7 +71,7 @@
 import org.apache.druid.server.http.CoordinatorDynamicConfigsResource;
 import org.apache.druid.server.http.CoordinatorRedirectInfo;
 import org.apache.druid.server.http.CoordinatorResource;
-import org.apache.druid.server.http.DatasourcesResource;
+import org.apache.druid.server.http.DataSourcesResource;
 import org.apache.druid.server.http.IntervalsResource;
 import org.apache.druid.server.http.LookupCoordinatorResource;
 import org.apache.druid.server.http.MetadataResource;
@@ -186,7 +186,7 @@ public void configure(Binder binder)
             Jerseys.addResource(binder, TiersResource.class);
             Jerseys.addResource(binder, RulesResource.class);
             Jerseys.addResource(binder, ServersResource.class);
-            Jerseys.addResource(binder, DatasourcesResource.class);
+            Jerseys.addResource(binder, DataSourcesResource.class);
             Jerseys.addResource(binder, MetadataResource.class);
             Jerseys.addResource(binder, IntervalsResource.class);
             Jerseys.addResource(binder, LookupCoordinatorResource.class);
@@ -194,7 +194,7 @@ public void configure(Binder binder)
             Jerseys.addResource(binder, HttpServerInventoryViewResource.class);
 
             LifecycleModule.register(binder, Server.class);
-            LifecycleModule.register(binder, DatasourcesResource.class);
+            LifecycleModule.register(binder, DataSourcesResource.class);
 
             ConditionalMultibind.create(
                 properties,
diff --git a/services/src/main/java/org/apache/druid/cli/CliRealtimeExample.java b/services/src/main/java/org/apache/druid/cli/CliRealtimeExample.java
index a066f9977e1a..64ad5e0550b5 100644
--- a/services/src/main/java/org/apache/druid/cli/CliRealtimeExample.java
+++ b/services/src/main/java/org/apache/druid/cli/CliRealtimeExample.java
@@ -105,7 +105,7 @@ public void registerSegmentCallback(Executor exec, SegmentCallback callback)
   private static class NoopInventoryView implements InventoryView
   {
     @Override
-    public DruidServer getInventoryValue(String string)
+    public DruidServer getInventoryValue(String serverKey)
     {
       return null;
     }
diff --git a/services/src/main/java/org/apache/druid/cli/DumpSegment.java b/services/src/main/java/org/apache/druid/cli/DumpSegment.java
index 28bfe0e71fce..596860499a77 100644
--- a/services/src/main/java/org/apache/druid/cli/DumpSegment.java
+++ b/services/src/main/java/org/apache/druid/cli/DumpSegment.java
@@ -81,6 +81,7 @@
 import org.apache.druid.segment.data.ConciseBitmapSerdeFactory;
 import org.apache.druid.segment.data.RoaringBitmapSerdeFactory;
 import org.apache.druid.segment.filter.Filters;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
 import org.joda.time.chrono.ISOChronology;
@@ -480,11 +481,12 @@ public int columnCacheSizeBytes()
   private static <T> Sequence<T> executeQuery(final Injector injector, final QueryableIndex index, final Query<T> query)
   {
     final QueryRunnerFactoryConglomerate conglomerate = injector.getInstance(QueryRunnerFactoryConglomerate.class);
-    final QueryRunnerFactory factory = conglomerate.findFactory(query);
-    final QueryRunner<T> runner = factory.createRunner(new QueryableIndexSegment("segment", index));
-    final Sequence results = factory.getToolchest().mergeResults(
-        factory.mergeRunners(MoreExecutors.sameThreadExecutor(), ImmutableList.of(runner))
-    ).run(QueryPlus.wrap(query), Maps.newHashMap());
+    final QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query);
+    final QueryRunner<T> runner = factory.createRunner(new QueryableIndexSegment(index, SegmentId.dummy("segment")));
+    final Sequence results = factory
+        .getToolchest()
+        .mergeResults(factory.mergeRunners(MoreExecutors.sameThreadExecutor(), ImmutableList.of(runner)))
+        .run(QueryPlus.wrap(query), Maps.newHashMap());
     return (Sequence<T>) results;
   }
 
diff --git a/services/src/main/java/org/apache/druid/cli/InsertSegment.java b/services/src/main/java/org/apache/druid/cli/InsertSegment.java
index 34f4974236e0..853d7ffa316e 100644
--- a/services/src/main/java/org/apache/druid/cli/InsertSegment.java
+++ b/services/src/main/java/org/apache/druid/cli/InsertSegment.java
@@ -119,12 +119,12 @@ private void insertSegments(final Set<DataSegment> segments) throws IOException
   {
     final Set<DataSegment> segmentsInserted = indexerMetadataStorageCoordinator.announceHistoricalSegments(segments);
     for (DataSegment dataSegment : segmentsInserted) {
-      log.info("Sucessfully inserted Segment [%s] into metadata storage", dataSegment.getIdentifier());
+      log.info("Sucessfully inserted Segment [%s] into metadata storage", dataSegment.getId());
     }
     final Set<DataSegment> segmentsAlreadyExist = Sets.difference(segments, segmentsInserted);
     if (!segmentsAlreadyExist.isEmpty()) {
       for (DataSegment dataSegment : segmentsAlreadyExist) {
-        log.info("Segment [%s] already exists in metadata storage, updating the payload", dataSegment.getIdentifier());
+        log.info("Segment [%s] already exists in metadata storage, updating the payload", dataSegment.getId());
       }
       indexerMetadataStorageCoordinator.updateSegmentMetadata(segmentsAlreadyExist);
     }
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/DruidPlanner.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/DruidPlanner.java
index 53fb0b1ae750..d9845688e2d8 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/DruidPlanner.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/DruidPlanner.java
@@ -162,7 +162,7 @@ private PlannerResult planWithDruidConvention(
         root.rel
     );
 
-    List<String> datasourceNames = druidRel.getDatasourceNames();
+    List<String> datasourceNames = druidRel.getDataSourceNames();
     // we'll eventually run a second authorization check at QueryLifecycle.runSimple(), so store the
     // authentication result in the planner context.
     Access authResult;
@@ -237,7 +237,7 @@ private Access authorizeBindableRel(
           public void visit(RelNode node, int ordinal, RelNode parent)
           {
             if (node instanceof DruidRel) {
-              datasourceNames.addAll(((DruidRel) node).getDatasourceNames());
+              datasourceNames.addAll(((DruidRel) node).getDataSourceNames());
             }
             if (node instanceof Bindables.BindableTableScan) {
               Bindables.BindableTableScan bts = (Bindables.BindableTableScan) node;
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidOuterQueryRel.java b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidOuterQueryRel.java
index 91dc11a12a17..efd738f1601e 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidOuterQueryRel.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidOuterQueryRel.java
@@ -206,9 +206,9 @@ public RelNode copy(final RelTraitSet traitSet, final List<RelNode> inputs)
   }
 
   @Override
-  public List<String> getDatasourceNames()
+  public List<String> getDataSourceNames()
   {
-    return ((DruidRel) sourceRel).getDatasourceNames();
+    return ((DruidRel) sourceRel).getDataSourceNames();
   }
 
   @Override
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQueryRel.java b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQueryRel.java
index dd9c5930eed2..ec3d742c77b4 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQueryRel.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidQueryRel.java
@@ -137,7 +137,7 @@ public DruidQueryRel asDruidConvention()
   }
 
   @Override
-  public List<String> getDatasourceNames()
+  public List<String> getDataSourceNames()
   {
     return druidTable.getDataSource().getNames();
   }
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidRel.java b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidRel.java
index bbf332ae92a1..06125402896c 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidRel.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidRel.java
@@ -122,7 +122,7 @@ public PlannerContext getPlannerContext()
   /**
    * Get a list of names of datasources read by this DruidRel
    */
-  public abstract List<String> getDatasourceNames();
+  public abstract List<String> getDataSourceNames();
 
   @Override
   public Class<Object[]> getElementType()
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidSemiJoin.java b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidSemiJoin.java
index 5360b690865a..06734bd0459b 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidSemiJoin.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidSemiJoin.java
@@ -187,12 +187,12 @@ public DruidSemiJoin asDruidConvention()
   }
 
   @Override
-  public List<String> getDatasourceNames()
+  public List<String> getDataSourceNames()
   {
     final DruidRel<?> druidRight = (DruidRel) this.right;
     Set<String> datasourceNames = new LinkedHashSet<>();
-    datasourceNames.addAll(left.getDatasourceNames());
-    datasourceNames.addAll(druidRight.getDatasourceNames());
+    datasourceNames.addAll(left.getDataSourceNames());
+    datasourceNames.addAll(druidRight.getDataSourceNames());
     return new ArrayList<>(datasourceNames);
   }
 
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidUnionRel.java b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidUnionRel.java
index 7b6fdde23a23..844f5f90221b 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidUnionRel.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/DruidUnionRel.java
@@ -180,10 +180,10 @@ public RelNode copy(final RelTraitSet traitSet, final List<RelNode> inputs)
   }
 
   @Override
-  public List<String> getDatasourceNames()
+  public List<String> getDataSourceNames()
   {
     return rels.stream()
-               .flatMap(rel -> ((DruidRel<?>) rel).getDatasourceNames().stream())
+               .flatMap(rel -> ((DruidRel<?>) rel).getDataSourceNames().stream())
                .distinct()
                .collect(Collectors.toList());
   }
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
index 1a9197e788f9..cc2681391675 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
@@ -24,10 +24,13 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.inject.Inject;
+import org.apache.calcite.schema.Table;
+import org.apache.calcite.schema.impl.AbstractSchema;
 import org.apache.druid.client.ServerView;
 import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.guice.ManageLifecycle;
@@ -57,8 +60,6 @@
 import org.apache.druid.sql.calcite.view.DruidViewMacro;
 import org.apache.druid.sql.calcite.view.ViewManager;
 import org.apache.druid.timeline.DataSegment;
-import org.apache.calcite.schema.Table;
-import org.apache.calcite.schema.impl.AbstractSchema;
 
 import java.io.IOException;
 import java.util.Comparator;
@@ -327,16 +328,16 @@ private void addSegment(final DruidServerMetadata server, final DataSegment segm
         segmentsNeedingRefresh.add(segment);
 
         if (!server.segmentReplicatable()) {
-          log.debug("Added new mutable segment[%s].", segment.getIdentifier());
+          log.debug("Added new mutable segment[%s].", segment.getId());
           mutableSegments.add(segment);
         } else {
-          log.debug("Added new immutable segment[%s].", segment.getIdentifier());
+          log.debug("Added new immutable segment[%s].", segment.getId());
         }
       } else if (server.segmentReplicatable()) {
         // If a segment shows up on a replicatable (historical) server at any point, then it must be immutable,
         // even if it's also available on non-replicatable (realtime) servers.
         mutableSegments.remove(segment);
-        log.debug("Segment[%s] has become immutable.", segment.getIdentifier());
+        log.debug("Segment[%s] has become immutable.", segment.getId());
       }
 
       if (!tables.containsKey(segment.getDataSource())) {
@@ -350,7 +351,7 @@ private void addSegment(final DruidServerMetadata server, final DataSegment segm
   private void removeSegment(final DataSegment segment)
   {
     synchronized (lock) {
-      log.debug("Segment[%s] is gone.", segment.getIdentifier());
+      log.debug("Segment[%s] is gone.", segment.getId());
 
       dataSourcesNeedingRebuild.add(segment.getDataSource());
       segmentsNeedingRefresh.remove(segment);
@@ -397,22 +398,15 @@ private Set<DataSegment> refreshSegments(final Set<DataSegment> segments) throws
    * Attempt to refresh "segmentSignatures" for a set of segments for a particular dataSource. Returns the set of
    * segments actually refreshed, which may be a subset of the asked-for set.
    */
-  private Set<DataSegment> refreshSegmentsForDataSource(
-      final String dataSource,
-      final Set<DataSegment> segments
-  ) throws IOException
+  private Set<DataSegment> refreshSegmentsForDataSource(final String dataSource, final Set<DataSegment> segments)
+      throws IOException
   {
     log.debug("Refreshing metadata for dataSource[%s].", dataSource);
 
     final long startTime = System.currentTimeMillis();
 
-    // Segment identifier -> segment object.
-    final Map<String, DataSegment> segmentMap = segments.stream().collect(
-        Collectors.toMap(
-            DataSegment::getIdentifier,
-            Function.identity()
-        )
-    );
+    // Segment id -> segment object.
+    final Map<String, DataSegment> segmentMap = Maps.uniqueIndex(segments, segment -> segment.getId().toString());
 
     final Set<DataSegment> retVal = new HashSet<>();
     final Sequence<SegmentAnalysis> sequence = runSegmentMetadataQuery(
@@ -432,7 +426,7 @@ private Set<DataSegment> refreshSegmentsForDataSource(
           log.warn("Got analysis for segment[%s] we didn't ask for, ignoring.", analysis.getId());
         } else {
           final RowSignature rowSignature = analysisToRowSignature(analysis);
-          log.debug("Segment[%s] has signature[%s].", segment.getIdentifier(), rowSignature);
+          log.debug("Segment[%s] has signature[%s].", segment.getId(), rowSignature);
           setSegmentSignature(segment, rowSignature);
           retVal.add(segment);
         }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SpecificSegmentsQuerySegmentWalker.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SpecificSegmentsQuerySegmentWalker.java
index d5ac4ceac261..80eeef2da023 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SpecificSegmentsQuerySegmentWalker.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SpecificSegmentsQuerySegmentWalker.java
@@ -75,9 +75,9 @@ public SpecificSegmentsQuerySegmentWalker add(
       final QueryableIndex index
   )
   {
-    final Segment segment = new QueryableIndexSegment(descriptor.getIdentifier(), index);
+    final Segment segment = new QueryableIndexSegment(index, descriptor.getId());
     if (!timelines.containsKey(descriptor.getDataSource())) {
-      timelines.put(descriptor.getDataSource(), new VersionedIntervalTimeline<String, Segment>(Ordering.natural()));
+      timelines.put(descriptor.getDataSource(), new VersionedIntervalTimeline<>(Ordering.natural()));
     }
 
     final VersionedIntervalTimeline<String, Segment> timeline = timelines.get(descriptor.getDataSource());

From bba860f2cb316e0ac666cd10277ad07a133e8c8b Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Mon, 24 Sep 2018 18:29:18 +0300
Subject: [PATCH 02/27] tmp

---
 codestyle/joda-time-forbidden-apis.txt        |  3 +-
 .../MaterializedViewSupervisor.java           |  2 +-
 .../DetermineHashedPartitionsJobTest.java     |  2 +-
 .../indexer/HadoopIngestionSpecTest.java      |  2 +-
 .../indexer/ITKafkaIndexingServiceTest.java   |  2 +-
 .../druid/tests/indexer/ITKafkaTest.java      |  2 +-
 .../druid/java/util/common/DateTimes.java     |  2 +-
 .../java/util/common/guava/Comparators.java   | 49 ++-----------------
 .../druid/java/util/common/DateTimesTest.java |  2 +-
 .../util/common/guava/ComparatorsTest.java    |  8 +--
 .../guava/nary/SortedMergeIteratorTest.java   |  4 +-
 .../DruidDefaultSerializersModule.java        |  2 +-
 .../druid/query/expression/ExprUtils.java     |  4 +-
 .../expression/TimestampParseExprMacro.java   |  2 +-
 .../select/SelectQueryQueryToolChest.java     | 29 +++++------
 .../select/SelectResultValueBuilder.java      |  8 +--
 .../query/topn/InvertedTopNMetricSpec.java    | 32 ++++++------
 .../granularity/QueryGranularityTest.java     | 16 +++---
 .../druid/query/QueryRunnerTestHelper.java    | 12 +----
 .../druid/query/TimewarpOperatorTest.java     |  6 +--
 .../TimeFormatExtractionFnTest.java           | 10 ++--
 .../query/groupby/GroupByQueryRunnerTest.java |  2 +-
 .../query/scan/MultiSegmentScanQueryTest.java |  2 +-
 .../select/MultiSegmentSelectQueryTest.java   |  4 +-
 .../select/SelectQueryQueryToolChestTest.java |  4 +-
 .../query/select/SelectQueryRunnerTest.java   | 34 +++++++------
 .../timeseries/TimeseriesQueryRunnerTest.java | 12 ++---
 .../segment/filter/TimeFilteringTest.java     |  2 +-
 .../DruidCoordinatorCleanupOvershadowed.java  |  4 +-
 .../druid/server/http/IntervalsResource.java  |  4 +-
 .../client/CachingClusteredClientTest.java    |  2 +-
 .../granularity/UniformGranularityTest.java   |  4 +-
 .../TimeExtractOperatorConversion.java        |  2 +-
 .../builtin/TimeFloorOperatorConversion.java  |  2 +-
 .../builtin/TimeFormatOperatorConversion.java |  2 +-
 .../sql/calcite/planner/PlannerContext.java   |  2 +-
 .../sql/avatica/DruidAvaticaHandlerTest.java  |  2 +-
 .../druid/sql/calcite/CalciteQueryTest.java   | 12 ++---
 .../calcite/expression/ExpressionsTest.java   |  2 +-
 39 files changed, 121 insertions(+), 176 deletions(-)

diff --git a/codestyle/joda-time-forbidden-apis.txt b/codestyle/joda-time-forbidden-apis.txt
index 33e93942213e..f2115b7abc8a 100644
--- a/codestyle/joda-time-forbidden-apis.txt
+++ b/codestyle/joda-time-forbidden-apis.txt
@@ -8,7 +8,6 @@ org.joda.time.DateTime#<init>(int, int, int, int, int, int, int)
 org.joda.time.DateTime#now()
 org.joda.time.DateTime#parse(java.lang.String)
 org.joda.time.DateTime#parse(java.lang.String, org.joda.time.format.DateTimeFormatter)
-org.joda.time.DateTimeZone#forID(java.lang.String)
 org.joda.time.base.BaseDateTime#<init>()
 org.joda.time.base.BaseDateTime#<init>(long)
 org.joda.time.base.BaseDateTime#<init>(int, int, int, int, int, int, int)
@@ -59,6 +58,8 @@ org.joda.time.MutableInterval#<init>(long, long)
 org.joda.time.MutableInterval#<init>(java.lang.Object)
 org.joda.time.MutableInterval#parse(java.lang.String)
 
+org.joda.time.DateTimeZone#forID(java.lang.String) @ Use DateTimes.inferTzFromString() instead
+
 @defaultMessage Uses default time zone, use DateTimes.UtcFormatter to parse.
 org.joda.time.format.DateTimeFormatter#parseInto(org.joda.time.ReadWritableInstant, java.lang.String, int)
 org.joda.time.format.DateTimeFormatter#parseDateTime(java.lang.String)
diff --git a/extensions-contrib/materialized-view-maintenance/src/main/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisor.java b/extensions-contrib/materialized-view-maintenance/src/main/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisor.java
index 488c6f81e28c..a7d52fa1d7e4 100644
--- a/extensions-contrib/materialized-view-maintenance/src/main/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisor.java
+++ b/extensions-contrib/materialized-view-maintenance/src/main/java/org/apache/druid/indexing/materializedview/MaterializedViewSupervisor.java
@@ -326,7 +326,7 @@ Pair<SortedMap<Interval, String>, Map<Interval, List<DataSegment>>> checkSegment
     Map<Interval, String> maxCreatedDate = baseSegmentsSnapshot.lhs;
     Map<Interval, String> derivativeVersion = derivativeSegmentsSnapshot.lhs;
     SortedMap<Interval, String> sortedToBuildInterval = Maps.newTreeMap(
-        Comparators.inverse(Comparators.intervalsByStartThenEnd())
+        Comparators.intervalsByStartThenEnd().reversed()
     );
     // find the intervals to drop and to build
     MapDifference<Interval, String> difference = Maps.difference(maxCreatedDate, derivativeVersion);
diff --git a/indexing-hadoop/src/test/java/org/apache/druid/indexer/DetermineHashedPartitionsJobTest.java b/indexing-hadoop/src/test/java/org/apache/druid/indexer/DetermineHashedPartitionsJobTest.java
index 208e24ed1e76..bbec6766419d 100644
--- a/indexing-hadoop/src/test/java/org/apache/druid/indexer/DetermineHashedPartitionsJobTest.java
+++ b/indexing-hadoop/src/test/java/org/apache/druid/indexer/DetermineHashedPartitionsJobTest.java
@@ -114,7 +114,7 @@ public static Collection<?> data()
                 0,
                 1,
                 first,
-                new PeriodGranularity(new Period("P1D"), null, DateTimes.inferTzfromString("America/Los_Angeles"))
+                new PeriodGranularity(new Period("P1D"), null, DateTimes.inferTzFromString("America/Los_Angeles"))
             }
         }
     );
diff --git a/indexing-hadoop/src/test/java/org/apache/druid/indexer/HadoopIngestionSpecTest.java b/indexing-hadoop/src/test/java/org/apache/druid/indexer/HadoopIngestionSpecTest.java
index a7c6ef1cf60f..83e4c8ac929f 100644
--- a/indexing-hadoop/src/test/java/org/apache/druid/indexer/HadoopIngestionSpecTest.java
+++ b/indexing-hadoop/src/test/java/org/apache/druid/indexer/HadoopIngestionSpecTest.java
@@ -118,7 +118,7 @@ public void testPeriodSegmentGranularitySpec()
 
     Assert.assertEquals(
         "getSegmentGranularity",
-        new PeriodGranularity(new Period("PT1H"), null, DateTimes.inferTzfromString("America/Los_Angeles")),
+        new PeriodGranularity(new Period("PT1H"), null, DateTimes.inferTzFromString("America/Los_Angeles")),
         granularitySpec.getSegmentGranularity()
     );
   }
diff --git a/integration-tests/src/test/java/org/apache/druid/tests/indexer/ITKafkaIndexingServiceTest.java b/integration-tests/src/test/java/org/apache/druid/tests/indexer/ITKafkaIndexingServiceTest.java
index 38b508c45394..29c7b9a90eaa 100644
--- a/integration-tests/src/test/java/org/apache/druid/tests/indexer/ITKafkaIndexingServiceTest.java
+++ b/integration-tests/src/test/java/org/apache/druid/tests/indexer/ITKafkaIndexingServiceTest.java
@@ -174,7 +174,7 @@ public void testKafka()
         new StringSerializer()
     );
 
-    DateTimeZone zone = DateTimes.inferTzfromString("UTC");
+    DateTimeZone zone = DateTimes.inferTzFromString("UTC");
     // format for putting into events
     DateTimeFormatter event_fmt = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss'Z'");
 
diff --git a/integration-tests/src/test/java/org/apache/druid/tests/indexer/ITKafkaTest.java b/integration-tests/src/test/java/org/apache/druid/tests/indexer/ITKafkaTest.java
index efbf2c29592a..585ddf178156 100644
--- a/integration-tests/src/test/java/org/apache/druid/tests/indexer/ITKafkaTest.java
+++ b/integration-tests/src/test/java/org/apache/druid/tests/indexer/ITKafkaTest.java
@@ -154,7 +154,7 @@ public void testKafka()
         new StringSerializer()
     );
 
-    DateTimeZone zone = DateTimes.inferTzfromString("UTC");
+    DateTimeZone zone = DateTimes.inferTzFromString("UTC");
     // format for putting into events
     DateTimeFormatter event_fmt = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss'Z'");
 
diff --git a/java-util/src/main/java/org/apache/druid/java/util/common/DateTimes.java b/java-util/src/main/java/org/apache/druid/java/util/common/DateTimes.java
index 969c01542dec..9631da9bd769 100644
--- a/java-util/src/main/java/org/apache/druid/java/util/common/DateTimes.java
+++ b/java-util/src/main/java/org/apache/druid/java/util/common/DateTimes.java
@@ -51,7 +51,7 @@ public final class DateTimes
       "[0-9]{4}-[01][0-9]-[0-3][0-9]T[0-2][0-9]:[0-5][0-9]:[0-5][0-9]\\.[0-9]{3}(Z|[+\\-][0-9]{2}(:[0-9]{2}))"
   );
 
-  public static DateTimeZone inferTzfromString(String tzId)
+  public static DateTimeZone inferTzFromString(String tzId)
   {
     try {
       return DateTimeZone.forID(tzId);
diff --git a/java-util/src/main/java/org/apache/druid/java/util/common/guava/Comparators.java b/java-util/src/main/java/org/apache/druid/java/util/common/guava/Comparators.java
index 500d5046bf11..61e1912d2eb0 100644
--- a/java-util/src/main/java/org/apache/druid/java/util/common/guava/Comparators.java
+++ b/java-util/src/main/java/org/apache/druid/java/util/common/guava/Comparators.java
@@ -20,7 +20,6 @@
 package org.apache.druid.java.util.common.guava;
 
 import com.google.common.collect.Ordering;
-import com.google.common.primitives.Longs;
 import org.joda.time.DateTimeComparator;
 import org.joda.time.Interval;
 
@@ -31,7 +30,6 @@
  */
 public class Comparators
 {
-
   private static final Ordering<Object> ALWAYS_EQUAL = new Ordering<Object>()
   {
     @SuppressWarnings("ComparatorMethodParameterNotUsed")
@@ -59,45 +57,6 @@ public static <T extends Comparable<? super T>> Ordering<T> naturalNullsFirst()
     return NATURAL_NULLS_FIRST;
   }
 
-  /**
-   * This is a "reverse" comparator.  Positive becomes negative, negative becomes positive and 0 (equal) stays the same.
-   * This was poorly named as "inverse" as it's not really inverting a true/false relationship
-   *
-   * @param baseComp
-   * @param <T>
-   * @return
-   */
-  public static <T> Comparator<T> inverse(final Comparator<T> baseComp)
-  {
-    return new Comparator<T>()
-    {
-      @Override
-      public int compare(T t, T t1)
-      {
-        return baseComp.compare(t1, t);
-      }
-    };
-  }
-
-  /**
-   * Use Guava Ordering.natural() instead
-   *
-   * @param <T>
-   * @return
-   */
-  @Deprecated
-  public static <T extends Comparable> Comparator<T> comparable()
-  {
-    return new Comparator<T>()
-    {
-      @Override
-      public int compare(T t, T t1)
-      {
-        return t.compareTo(t1);
-      }
-    };
-  }
-
   private static final Comparator<Interval> INTERVAL_BY_START_THEN_END = new Comparator<Interval>()
   {
     private final DateTimeComparator dateTimeComp = DateTimeComparator.getInstance();
@@ -106,9 +65,9 @@ public int compare(T t, T t1)
     public int compare(Interval lhs, Interval rhs)
     {
       if (lhs.getChronology().equals(rhs.getChronology())) {
-        int compare = Longs.compare(lhs.getStartMillis(), rhs.getStartMillis());
+        int compare = Long.compare(lhs.getStartMillis(), rhs.getStartMillis());
         if (compare == 0) {
-          return Longs.compare(lhs.getEndMillis(), rhs.getEndMillis());
+          return Long.compare(lhs.getEndMillis(), rhs.getEndMillis());
         }
         return compare;
       }
@@ -128,9 +87,9 @@ public int compare(Interval lhs, Interval rhs)
     public int compare(Interval lhs, Interval rhs)
     {
       if (lhs.getChronology().equals(rhs.getChronology())) {
-        int compare = Longs.compare(lhs.getEndMillis(), rhs.getEndMillis());
+        int compare = Long.compare(lhs.getEndMillis(), rhs.getEndMillis());
         if (compare == 0) {
-          return Longs.compare(lhs.getStartMillis(), rhs.getStartMillis());
+          return Long.compare(lhs.getStartMillis(), rhs.getStartMillis());
         }
         return compare;
       }
diff --git a/java-util/src/test/java/org/apache/druid/java/util/common/DateTimesTest.java b/java-util/src/test/java/org/apache/druid/java/util/common/DateTimesTest.java
index ab99084aa2f7..86eae3d15bdb 100644
--- a/java-util/src/test/java/org/apache/druid/java/util/common/DateTimesTest.java
+++ b/java-util/src/test/java/org/apache/druid/java/util/common/DateTimesTest.java
@@ -31,7 +31,7 @@ public class DateTimesTest
   public void testCommonDateTimePattern()
   {
     DateTime dt1 = DateTimes.nowUtc();
-    DateTime dt2 = new DateTime(System.currentTimeMillis(), DateTimeZone.forID("IST"));
+    DateTime dt2 = new DateTime(System.currentTimeMillis(), DateTimes.inferTzFromString("IST"));
     DateTime dt3 = new DateTime(System.currentTimeMillis(), DateTimeZone.forOffsetHoursMinutes(1, 30));
 
     for (DateTime dt : new DateTime[] {dt1, dt2, dt3}) {
diff --git a/java-util/src/test/java/org/apache/druid/java/util/common/guava/ComparatorsTest.java b/java-util/src/test/java/org/apache/druid/java/util/common/guava/ComparatorsTest.java
index 61ab1e4577da..0cc4dda49ba9 100644
--- a/java-util/src/test/java/org/apache/druid/java/util/common/guava/ComparatorsTest.java
+++ b/java-util/src/test/java/org/apache/druid/java/util/common/guava/ComparatorsTest.java
@@ -34,8 +34,8 @@ public class ComparatorsTest
   @Test
   public void testInverse()
   {
-    Comparator<Integer> normal = Comparators.comparable();
-    Comparator<Integer> inverted = Comparators.inverse(normal);
+    Comparator<Integer> normal = Comparator.naturalOrder();
+    Comparator<Integer> inverted = normal.reversed();
 
     Assert.assertEquals(-1, normal.compare(0, 1));
     Assert.assertEquals(1, normal.compare(1, 0));
@@ -48,14 +48,14 @@ public void testInverse()
   @Test
   public void testInverseOverflow()
   {
-    Comparator<Integer> invertedSimpleIntegerComparator = Comparators.inverse(new Comparator<Integer>()
+    Comparator<Integer> invertedSimpleIntegerComparator = new Comparator<Integer>()
     {
       @Override
       public int compare(Integer o1, Integer o2)
       {
         return o1 - o2;
       }
-    });
+    }.reversed();
     Assert.assertTrue(invertedSimpleIntegerComparator.compare(0, Integer.MIN_VALUE) < 0);
   }
 
diff --git a/java-util/src/test/java/org/apache/druid/java/util/common/guava/nary/SortedMergeIteratorTest.java b/java-util/src/test/java/org/apache/druid/java/util/common/guava/nary/SortedMergeIteratorTest.java
index a17a75e656d8..97953dab2c6c 100644
--- a/java-util/src/test/java/org/apache/druid/java/util/common/guava/nary/SortedMergeIteratorTest.java
+++ b/java-util/src/test/java/org/apache/druid/java/util/common/guava/nary/SortedMergeIteratorTest.java
@@ -20,11 +20,11 @@
 package org.apache.druid.java.util.common.guava.nary;
 
 import com.google.common.collect.Lists;
-import org.apache.druid.java.util.common.guava.Comparators;
 import org.junit.Assert;
 import org.junit.Test;
 
 import java.util.Arrays;
+import java.util.Comparator;
 
 /**
  */
@@ -36,7 +36,7 @@ public void testSanity()
     SortedMergeIterator<Integer, Integer> iter = SortedMergeIterator.create(
         Arrays.asList(1, 4, 5, 7, 9).iterator(),
         Arrays.asList(1, 2, 3, 6, 7, 8, 9, 10, 11).iterator(),
-        Comparators.comparable(),
+        Comparator.naturalOrder(),
         new BinaryFn<Integer, Integer, Integer>()
         {
           @Override
diff --git a/processing/src/main/java/org/apache/druid/jackson/DruidDefaultSerializersModule.java b/processing/src/main/java/org/apache/druid/jackson/DruidDefaultSerializersModule.java
index 10bd8785337e..994738a88543 100644
--- a/processing/src/main/java/org/apache/druid/jackson/DruidDefaultSerializersModule.java
+++ b/processing/src/main/java/org/apache/druid/jackson/DruidDefaultSerializersModule.java
@@ -57,7 +57,7 @@ public DateTimeZone deserialize(JsonParser jp, DeserializationContext ctxt)
               throws IOException
           {
             String tzId = jp.getText();
-            return DateTimes.inferTzfromString(tzId);
+            return DateTimes.inferTzFromString(tzId);
           }
         }
     );
diff --git a/processing/src/main/java/org/apache/druid/query/expression/ExprUtils.java b/processing/src/main/java/org/apache/druid/query/expression/ExprUtils.java
index 0ff6532321f0..1b9cb9df16ab 100644
--- a/processing/src/main/java/org/apache/druid/query/expression/ExprUtils.java
+++ b/processing/src/main/java/org/apache/druid/query/expression/ExprUtils.java
@@ -48,7 +48,7 @@ public static DateTimeZone toTimeZone(final Expr timeZoneArg)
     }
 
     final Object literalValue = timeZoneArg.getLiteralValue();
-    return literalValue == null ? DateTimeZone.UTC : DateTimes.inferTzfromString((String) literalValue);
+    return literalValue == null ? DateTimeZone.UTC : DateTimes.inferTzFromString((String) literalValue);
   }
 
   public static PeriodGranularity toPeriodGranularity(
@@ -66,7 +66,7 @@ public static PeriodGranularity toPeriodGranularity(
       timeZone = null;
     } else {
       final String value = timeZoneArg.eval(bindings).asString();
-      timeZone = value != null ? DateTimes.inferTzfromString(value) : null;
+      timeZone = value != null ? DateTimes.inferTzFromString(value) : null;
     }
 
     if (originArg == null) {
diff --git a/processing/src/main/java/org/apache/druid/query/expression/TimestampParseExprMacro.java b/processing/src/main/java/org/apache/druid/query/expression/TimestampParseExprMacro.java
index 8e4ace7d089f..2b65fb54653e 100644
--- a/processing/src/main/java/org/apache/druid/query/expression/TimestampParseExprMacro.java
+++ b/processing/src/main/java/org/apache/druid/query/expression/TimestampParseExprMacro.java
@@ -54,7 +54,7 @@ public Expr apply(final List<Expr> args)
     final DateTimeZone timeZone;
 
     if (args.size() > 2 && args.get(2).getLiteralValue() != null) {
-      timeZone = DateTimes.inferTzfromString((String) args.get(2).getLiteralValue());
+      timeZone = DateTimes.inferTzFromString((String) args.get(2).getLiteralValue());
     } else {
       timeZone = DateTimeZone.UTC;
     }
diff --git a/processing/src/main/java/org/apache/druid/query/select/SelectQueryQueryToolChest.java b/processing/src/main/java/org/apache/druid/query/select/SelectQueryQueryToolChest.java
index d9e8577fbba5..4760332a58ca 100644
--- a/processing/src/main/java/org/apache/druid/query/select/SelectQueryQueryToolChest.java
+++ b/processing/src/main/java/org/apache/druid/query/select/SelectQueryQueryToolChest.java
@@ -286,22 +286,22 @@ public Result<SelectResultValue> apply(Object input)
             DateTime timestamp = granularity.toDateTime(((Number) resultIter.next()).longValue());
 
             Map<String, Integer> pageIdentifier = jsonMapper.convertValue(
-                resultIter.next(), new TypeReference<Map<String, Integer>>() {}
-                );
-            Set<String> dimensionSet = jsonMapper.convertValue(
-                resultIter.next(), new TypeReference<Set<String>>() {}
-            );
-            Set<String> metricSet = jsonMapper.convertValue(
-                resultIter.next(), new TypeReference<Set<String>>() {}
+                resultIter.next(),
+                new TypeReference<Map<String, Integer>>() {}
             );
+            Set<String> dimensionSet = jsonMapper.convertValue(resultIter.next(), new TypeReference<Set<String>>() {});
+            Set<String> metricSet = jsonMapper.convertValue(resultIter.next(), new TypeReference<Set<String>>() {});
             List<EventHolder> eventHolders = jsonMapper.convertValue(
-                resultIter.next(), new TypeReference<List<EventHolder>>() {}
-                );
+                resultIter.next(),
+                new TypeReference<List<EventHolder>>() {}
+            );
             // check the condition that outputName of cached result should be updated
             if (resultIter.hasNext()) {
               List<String> cachedOutputNames = (List<String>) resultIter.next();
-              Preconditions.checkArgument(cachedOutputNames.size() == dimOutputNames.size(),
-                  "Cache hit but different number of dimensions??");
+              Preconditions.checkArgument(
+                  cachedOutputNames.size() == dimOutputNames.size(),
+                  "Cache hit but different number of dimensions??"
+              );
               for (int idx = 0; idx < dimOutputNames.size(); idx++) {
                 if (!cachedOutputNames.get(idx).equals(dimOutputNames.get(idx))) {
                   // rename outputName in the EventHolder
@@ -317,12 +317,7 @@ public Result<SelectResultValue> apply(Object input)
 
             return new Result<>(
                 timestamp,
-                new SelectResultValue(
-                    pageIdentifier,
-                    dimensionSet,
-                    metricSet,
-                    eventHolders
-                )
+                new SelectResultValue(pageIdentifier, dimensionSet, metricSet, eventHolders)
             );
           }
         };
diff --git a/processing/src/main/java/org/apache/druid/query/select/SelectResultValueBuilder.java b/processing/src/main/java/org/apache/druid/query/select/SelectResultValueBuilder.java
index a4ded3feee60..2d53cd0e57c8 100644
--- a/processing/src/main/java/org/apache/druid/query/select/SelectResultValueBuilder.java
+++ b/processing/src/main/java/org/apache/druid/query/select/SelectResultValueBuilder.java
@@ -25,7 +25,6 @@
 import com.google.common.collect.Queues;
 import com.google.common.collect.Sets;
 import com.google.common.primitives.Longs;
-import org.apache.druid.java.util.common.guava.Comparators;
 import org.apache.druid.query.Result;
 import org.joda.time.DateTime;
 
@@ -110,10 +109,7 @@ public void addMetrics(Set<String> metrics)
 
   public Result<SelectResultValue> build()
   {
-    return new Result<SelectResultValue>(
-        timestamp,
-        new SelectResultValue(pagingIdentifiers, dimensions, metrics, getEventHolders())
-    );
+    return new Result<>(timestamp, new SelectResultValue(pagingIdentifiers, dimensions, metrics, getEventHolders()));
   }
 
   protected List<EventHolder> getEventHolders()
@@ -137,7 +133,7 @@ public MergeBuilder(DateTime timestamp, PagingSpec pagingSpec, boolean descendin
     protected Queue<EventHolder> instantiatePQueue()
     {
       int threshold = pagingSpec.getThreshold();
-      return MinMaxPriorityQueue.orderedBy(descending ? Comparators.inverse(comparator) : comparator)
+      return MinMaxPriorityQueue.orderedBy(descending ? comparator.reversed() : comparator)
                                 .maximumSize(threshold > 0 ? threshold : Integer.MAX_VALUE)
                                 .create();
     }
diff --git a/processing/src/main/java/org/apache/druid/query/topn/InvertedTopNMetricSpec.java b/processing/src/main/java/org/apache/druid/query/topn/InvertedTopNMetricSpec.java
index b4c8cbc5f58c..d168f9b1f174 100644
--- a/processing/src/main/java/org/apache/druid/query/topn/InvertedTopNMetricSpec.java
+++ b/processing/src/main/java/org/apache/druid/query/topn/InvertedTopNMetricSpec.java
@@ -21,7 +21,6 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import org.apache.druid.java.util.common.guava.Comparators;
 import org.apache.druid.query.aggregation.AggregatorFactory;
 import org.apache.druid.query.aggregation.PostAggregator;
 import org.apache.druid.query.dimension.DimensionSpec;
@@ -67,23 +66,22 @@ public Comparator getComparator(
       final List<PostAggregator> postAggregatorSpecs
   )
   {
-    return Comparators.inverse(
-        new Comparator()
-        {
-          @Override
-          public int compare(Object o1, Object o2)
-          {
-            // nulls last
-            if (o1 == null) {
-              return 1;
-            }
-            if (o2 == null) {
-              return -1;
-            }
-            return delegate.getComparator(aggregatorSpecs, postAggregatorSpecs).compare(o1, o2);
-          }
+    // nulls last
+    return ((Comparator<Object>) new Comparator()
+    {
+      @Override
+      public int compare(Object o1, Object o2)
+      {
+        // nulls last
+        if (o1 == null) {
+          return 1;
         }
-    );
+        if (o2 == null) {
+          return -1;
+        }
+        return delegate.getComparator(aggregatorSpecs, postAggregatorSpecs).compare(o1, o2);
+      }
+    }).reversed();
   }
 
   @Override
diff --git a/processing/src/test/java/org/apache/druid/granularity/QueryGranularityTest.java b/processing/src/test/java/org/apache/druid/granularity/QueryGranularityTest.java
index 1485e846ee21..e50d6deb5272 100644
--- a/processing/src/test/java/org/apache/druid/granularity/QueryGranularityTest.java
+++ b/processing/src/test/java/org/apache/druid/granularity/QueryGranularityTest.java
@@ -317,7 +317,7 @@ public void testIterableYearComplex()
   @Test
   public void testPeriodDaylightSaving()
   {
-    final DateTimeZone tz = DateTimes.inferTzfromString("America/Los_Angeles");
+    final DateTimeZone tz = DateTimes.inferTzFromString("America/Los_Angeles");
     final DateTime baseTime = new DateTime("2012-11-04T00:00:00", tz);
     assertSameInterval(
         Lists.newArrayList(
@@ -363,7 +363,7 @@ public void testPeriodDaylightSaving()
   @Test
   public void testIterableMonth()
   {
-    final DateTimeZone tz = DateTimes.inferTzfromString("America/Los_Angeles");
+    final DateTimeZone tz = DateTimes.inferTzFromString("America/Los_Angeles");
     final DateTime baseTime = new DateTime("2012-11-03T10:00:00", tz);
     assertSameInterval(
         Lists.newArrayList(
@@ -380,7 +380,7 @@ public void testIterableMonth()
   @Test
   public void testIterableWeek()
   {
-    final DateTimeZone tz = DateTimes.inferTzfromString("America/Los_Angeles");
+    final DateTimeZone tz = DateTimes.inferTzFromString("America/Los_Angeles");
     final DateTime baseTime = new DateTime("2012-11-03T10:00:00", tz);
     assertSameInterval(
         Lists.newArrayList(
@@ -407,7 +407,7 @@ public void testIterableWeek()
   @Test
   public void testPeriodTruncateDays()
   {
-    final DateTimeZone tz = DateTimes.inferTzfromString("America/Los_Angeles");
+    final DateTimeZone tz = DateTimes.inferTzFromString("America/Los_Angeles");
     final DateTime origin = DateTimes.of("2012-01-02T05:00:00.000-08:00");
     PeriodGranularity periodOrigin = new PeriodGranularity(
         new Period("P2D"),
@@ -487,7 +487,7 @@ public void testPeriodTruncateMinutes()
   public void testCompoundPeriodTruncate()
   {
     {
-      final DateTimeZone tz = DateTimes.inferTzfromString("America/Los_Angeles");
+      final DateTimeZone tz = DateTimes.inferTzFromString("America/Los_Angeles");
       final DateTime origin = DateTimes.of("2012-01-02T05:00:00.000-08:00");
       PeriodGranularity periodOrigin = new PeriodGranularity(
           new Period("P1M2D"),
@@ -532,7 +532,7 @@ public void testCompoundPeriodTruncate()
     }
 
     {
-      final DateTimeZone tz = DateTimes.inferTzfromString("America/Los_Angeles");
+      final DateTimeZone tz = DateTimes.inferTzFromString("America/Los_Angeles");
       final DateTime origin = DateTimes.of("2012-01-02T05:00:00.000-08:00");
       PeriodGranularity periodOrigin = new PeriodGranularity(
           new Period("PT12H5M"),
@@ -668,13 +668,13 @@ public void testSerializePeriod() throws Exception
     Assert.assertEquals(new PeriodGranularity(
         new Period("P1D"),
         DateTimes.EPOCH,
-        DateTimes.inferTzfromString("America/Los_Angeles")
+        DateTimes.inferTzFromString("America/Los_Angeles")
     ), gran);
 
     PeriodGranularity expected = new PeriodGranularity(
         new Period("P1D"),
         DateTimes.of("2012-01-01"),
-        DateTimes.inferTzfromString("America/Los_Angeles")
+        DateTimes.inferTzFromString("America/Los_Angeles")
     );
 
     String jsonOut = mapper.writeValueAsString(expected);
diff --git a/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java b/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
index e72f68124e40..dbe3dfbe77d5 100644
--- a/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
+++ b/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
@@ -86,17 +86,7 @@ public class QueryRunnerTestHelper
   public static final SegmentId segmentId = SegmentId.dummy("testSegment");
   public static final String dataSource = "testing";
   public static final UnionDataSource unionDataSource = new UnionDataSource(
-      Lists.transform(
-          Lists.newArrayList(dataSource, dataSource, dataSource, dataSource), new Function<String, TableDataSource>()
-          {
-            @Nullable
-            @Override
-            public TableDataSource apply(@Nullable String input)
-            {
-              return new TableDataSource(input);
-            }
-          }
-      )
+      Lists.transform(Lists.newArrayList(dataSource, dataSource, dataSource, dataSource), TableDataSource::new)
   );
 
   public static final Granularity dayGran = Granularities.DAY;
diff --git a/processing/src/test/java/org/apache/druid/query/TimewarpOperatorTest.java b/processing/src/test/java/org/apache/druid/query/TimewarpOperatorTest.java
index 97f5d253ab0c..c3bab6196ca8 100644
--- a/processing/src/test/java/org/apache/druid/query/TimewarpOperatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/TimewarpOperatorTest.java
@@ -74,7 +74,7 @@ public void testComputeOffset()
 
       Assert.assertEquals(
           tOffset,
-          t.plus(testOperator.computeOffset(t.getMillis(), DateTimes.inferTzfromString("America/Los_Angeles")))
+          t.plus(testOperator.computeOffset(t.getMillis(), DateTimes.inferTzFromString("America/Los_Angeles")))
       );
     }
   }
@@ -225,7 +225,7 @@ public Sequence<Result<TimeseriesResultValue>> run(
         Druids.newTimeseriesQueryBuilder()
               .dataSource("dummy")
               .intervals("2014-07-31T-07/2014-08-05T-07")
-              .granularity(new PeriodGranularity(new Period("P1D"), null, DateTimes.inferTzfromString("America/Los_Angeles")))
+              .granularity(new PeriodGranularity(new Period("P1D"), null, DateTimes.inferTzFromString("America/Los_Angeles")))
               .aggregators(Collections.singletonList(new CountAggregatorFactory("count")))
               .build();
 
@@ -285,7 +285,7 @@ public Sequence<Result<TimeseriesResultValue>> run(
         Druids.newTimeseriesQueryBuilder()
               .dataSource("dummy")
               .intervals("2014-07-31T-07/2014-08-05T-07")
-              .granularity(new PeriodGranularity(new Period("P1D"), null, DateTimes.inferTzfromString("America/Phoenix")))
+              .granularity(new PeriodGranularity(new Period("P1D"), null, DateTimes.inferTzFromString("America/Phoenix")))
               .aggregators(Collections.singletonList(new CountAggregatorFactory("count")))
               .build();
 
diff --git a/processing/src/test/java/org/apache/druid/query/extraction/TimeFormatExtractionFnTest.java b/processing/src/test/java/org/apache/druid/query/extraction/TimeFormatExtractionFnTest.java
index 14a1282a6568..70035f72d4c1 100644
--- a/processing/src/test/java/org/apache/druid/query/extraction/TimeFormatExtractionFnTest.java
+++ b/processing/src/test/java/org/apache/druid/query/extraction/TimeFormatExtractionFnTest.java
@@ -89,7 +89,7 @@ public void testTimeZoneExtraction() throws Exception
   {
     TimeFormatExtractionFn fn = new TimeFormatExtractionFn(
         "'In Berlin ist es schon 'EEEE",
-        DateTimes.inferTzfromString("Europe/Berlin"),
+        DateTimes.inferTzFromString("Europe/Berlin"),
         "de",
         null,
         false
@@ -101,7 +101,7 @@ public void testTimeZoneExtraction() throws Exception
     Assert.assertEquals("In Berlin ist es schon Sonntag", fn.apply(timestamps[4]));
     Assert.assertEquals("In Berlin ist es schon Dienstag", fn.apply(timestamps[5]));
 
-    testSerde(fn, "'In Berlin ist es schon 'EEEE", DateTimes.inferTzfromString("Europe/Berlin"), "de", Granularities.NONE);
+    testSerde(fn, "'In Berlin ist es schon 'EEEE", DateTimes.inferTzFromString("Europe/Berlin"), "de", Granularities.NONE);
   }
 
   public void testSerde(
@@ -149,7 +149,7 @@ public void testCacheKey()
   {
     TimeFormatExtractionFn fn = new TimeFormatExtractionFn(
         "'In Berlin ist es schon 'EEEE",
-        DateTimes.inferTzfromString("Europe/Berlin"),
+        DateTimes.inferTzFromString("Europe/Berlin"),
         "de",
         null,
         false
@@ -157,7 +157,7 @@ public void testCacheKey()
 
     TimeFormatExtractionFn fn2 = new TimeFormatExtractionFn(
         "'In Berlin ist es schon 'EEEE",
-        DateTimes.inferTzfromString("Europe/Berlin"),
+        DateTimes.inferTzFromString("Europe/Berlin"),
         "de",
         null,
         true
@@ -165,7 +165,7 @@ public void testCacheKey()
 
     TimeFormatExtractionFn fn3 = new TimeFormatExtractionFn(
         "'In Berlin ist es schon 'EEEE",
-        DateTimes.inferTzfromString("Europe/Berlin"),
+        DateTimes.inferTzFromString("Europe/Berlin"),
         "de",
         null,
         true
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
index 7697506dd7d8..dda2e47e34aa 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
@@ -2142,7 +2142,7 @@ public String apply(String dimValue)
   @Test
   public void testGroupByWithTimeZone()
   {
-    DateTimeZone tz = DateTimes.inferTzfromString("America/Los_Angeles");
+    DateTimeZone tz = DateTimes.inferTzFromString("America/Los_Angeles");
 
     GroupByQuery query = GroupByQuery.builder()
                                      .setDataSource(QueryRunnerTestHelper.dataSource)
diff --git a/processing/src/test/java/org/apache/druid/query/scan/MultiSegmentScanQueryTest.java b/processing/src/test/java/org/apache/druid/query/scan/MultiSegmentScanQueryTest.java
index 1349e1cf1419..c94a7ef9d477 100644
--- a/processing/src/test/java/org/apache/druid/query/scan/MultiSegmentScanQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/scan/MultiSegmentScanQueryTest.java
@@ -177,7 +177,7 @@ private ScanQuery.ScanQueryBuilder newBuilder()
   {
     return ScanQuery.newScanQueryBuilder()
                     .dataSource(new TableDataSource(QueryRunnerTestHelper.dataSource))
-                    .intervals(SelectQueryRunnerTest.I_0112_0114)
+                    .intervals(SelectQueryRunnerTest.I_0112_0114_SPEC)
                     .batchSize(batchSize)
                     .columns(Collections.emptyList())
                     .legacy(false)
diff --git a/processing/src/test/java/org/apache/druid/query/select/MultiSegmentSelectQueryTest.java b/processing/src/test/java/org/apache/druid/query/select/MultiSegmentSelectQueryTest.java
index 7080442f0b3c..fae209cba431 100644
--- a/processing/src/test/java/org/apache/druid/query/select/MultiSegmentSelectQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/select/MultiSegmentSelectQueryTest.java
@@ -215,7 +215,7 @@ private Druids.SelectQueryBuilder newBuilder()
   {
     return Druids.newSelectQueryBuilder()
                  .dataSource(new TableDataSource(QueryRunnerTestHelper.dataSource))
-                 .intervals(SelectQueryRunnerTest.I_0112_0114)
+                 .intervals(SelectQueryRunnerTest.I_0112_0114_SPEC)
                  .granularity(QueryRunnerTestHelper.allGran)
                  .dimensionSpecs(DefaultDimensionSpec.toSpec(QueryRunnerTestHelper.dimensions))
                  .pagingSpec(PagingSpec.newSpec(3));
@@ -322,7 +322,7 @@ public void testPagingIdentifiersForUnionDatasource()
                 )
             )
         )
-        .intervals(SelectQueryRunnerTest.I_0112_0114)
+        .intervals(SelectQueryRunnerTest.I_0112_0114_SPEC)
         .granularity(QueryRunnerTestHelper.allGran)
         .dimensionSpecs(DefaultDimensionSpec.toSpec(QueryRunnerTestHelper.dimensions))
         .pagingSpec(PagingSpec.newSpec(3));
diff --git a/processing/src/test/java/org/apache/druid/query/select/SelectQueryQueryToolChestTest.java b/processing/src/test/java/org/apache/druid/query/select/SelectQueryQueryToolChestTest.java
index 45f653643e3f..5d9da392a89c 100644
--- a/processing/src/test/java/org/apache/druid/query/select/SelectQueryQueryToolChestTest.java
+++ b/processing/src/test/java/org/apache/druid/query/select/SelectQueryQueryToolChestTest.java
@@ -48,7 +48,7 @@ public void testComputeCacheKeyWithDifferentSortOrer()
     final SelectQuery query1 = Druids.newSelectQueryBuilder()
                                      .dataSource("dummy")
                                      .dimensions(Collections.singletonList("testDim"))
-                                     .intervals(SelectQueryRunnerTest.I_0112_0114)
+                                     .intervals(SelectQueryRunnerTest.I_0112_0114_SPEC)
                                      .granularity(QueryRunnerTestHelper.allGran)
                                      .pagingSpec(PagingSpec.newSpec(3))
                                      .descending(false)
@@ -57,7 +57,7 @@ public void testComputeCacheKeyWithDifferentSortOrer()
     final SelectQuery query2 = Druids.newSelectQueryBuilder()
                                      .dataSource("dummy")
                                      .dimensions(Collections.singletonList("testDim"))
-                                     .intervals(SelectQueryRunnerTest.I_0112_0114)
+                                     .intervals(SelectQueryRunnerTest.I_0112_0114_SPEC)
                                      .granularity(QueryRunnerTestHelper.allGran)
                                      .pagingSpec(PagingSpec.newSpec(3))
                                      .descending(true)
diff --git a/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
index 09f01eea0052..0c0089e16837 100644
--- a/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
@@ -56,7 +56,9 @@
 import org.apache.druid.segment.column.Column;
 import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
+import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTime;
+import org.joda.time.Interval;
 import org.joda.time.chrono.ISOChronology;
 import org.junit.Assert;
 import org.junit.Test;
@@ -110,7 +112,11 @@ public class SelectQueryRunnerTest
 
   private static final String segmentIdString = QueryRunnerTestHelper.segmentId.toString();
 
-  public static final QuerySegmentSpec I_0112_0114 = new LegacySegmentSpec(Intervals.of("2011-01-12/2011-01-14"));
+
+  private static final Interval I_0112_0114 = Intervals.of("2011-01-12/2011-01-14");
+  public static final QuerySegmentSpec I_0112_0114_SPEC = new LegacySegmentSpec(I_0112_0114);
+  private static final SegmentId SEGMENT_ID_I_0112_0114 = QueryRunnerTestHelper.segmentId.withInterval(I_0112_0114);
+
   public static final String[] V_0112_0114 = ObjectArrays.concat(V_0112, V_0113, String.class);
 
   private static final boolean DEFAULT_FROM_NEXT = true;
@@ -165,7 +171,7 @@ private Druids.SelectQueryBuilder newTestQuery()
   public void testFullOnSelect()
   {
     SelectQuery query = newTestQuery()
-        .intervals(I_0112_0114)
+        .intervals(I_0112_0114_SPEC)
         .build();
 
     HashMap<String, Object> context = new HashMap<String, Object>();
@@ -208,7 +214,7 @@ public void testSequentialPaging()
     int[] dsc = {-3, -6, -9, -12, -15, -18, -21, -24, -26};
     int[] expected = descending ? dsc : asc;
 
-    SelectQuery query = newTestQuery().intervals(I_0112_0114).build();
+    SelectQuery query = newTestQuery().intervals(I_0112_0114_SPEC).build();
     for (int offset : expected) {
       List<Result<SelectResultValue>> results = runner.run(QueryPlus.wrap(query), ImmutableMap.of()).toList();
 
@@ -216,13 +222,13 @@ public void testSequentialPaging()
 
       SelectResultValue result = results.get(0).getValue();
       Map<String, Integer> pagingIdentifiers = result.getPagingIdentifiers();
-      Assert.assertEquals(offset, pagingIdentifiers.get(segmentIdString).intValue());
+      Assert.assertEquals(offset, pagingIdentifiers.get(SEGMENT_ID_I_0112_0114.toString()).intValue());
 
       Map<String, Integer> next = PagingSpec.next(pagingIdentifiers, descending);
       query = query.withPagingSpec(new PagingSpec(next, 3, false));
     }
 
-    query = newTestQuery().intervals(I_0112_0114).build();
+    query = newTestQuery().intervals(I_0112_0114_SPEC).build();
     for (int offset : expected) {
       List<Result<SelectResultValue>> results = runner.run(QueryPlus.wrap(query), ImmutableMap.of()).toList();
 
@@ -230,7 +236,7 @@ public void testSequentialPaging()
 
       SelectResultValue result = results.get(0).getValue();
       Map<String, Integer> pagingIdentifiers = result.getPagingIdentifiers();
-      Assert.assertEquals(offset, pagingIdentifiers.get(segmentIdString).intValue());
+      Assert.assertEquals(offset, pagingIdentifiers.get(SEGMENT_ID_I_0112_0114.toString()).intValue());
 
       // use identifier as-is but with fromNext=true
       query = query.withPagingSpec(new PagingSpec(pagingIdentifiers, 3, true));
@@ -371,7 +377,7 @@ public void testFullOnSelectWithDimensionSpec()
   public void testSelectWithDimsAndMets()
   {
     SelectQuery query = newTestQuery()
-        .intervals(I_0112_0114)
+        .intervals(I_0112_0114_SPEC)
         .dimensionSpecs(DefaultDimensionSpec.toSpec(QueryRunnerTestHelper.marketDimension))
         .metrics(Collections.singletonList(QueryRunnerTestHelper.indexMetric))
         .build();
@@ -407,7 +413,7 @@ public void testSelectWithDimsAndMets()
   public void testSelectPagination()
   {
     SelectQuery query = newTestQuery()
-        .intervals(I_0112_0114)
+        .intervals(I_0112_0114_SPEC)
         .dimensionSpecs(DefaultDimensionSpec.toSpec(QueryRunnerTestHelper.qualityDimension))
         .metrics(Collections.singletonList(QueryRunnerTestHelper.indexMetric))
         .pagingSpec(new PagingSpec(toPagingIdentifier(3, descending), 3))
@@ -439,7 +445,7 @@ public void testFullOnSelectWithFilter()
     // startDelta + threshold pairs
     for (int[] param : new int[][]{{3, 3}, {0, 1}, {5, 5}, {2, 7}, {3, 0}}) {
       SelectQuery query = newTestQuery()
-          .intervals(I_0112_0114)
+          .intervals(I_0112_0114_SPEC)
           .filters(new SelectorDimFilter(QueryRunnerTestHelper.marketDimension, "spot", null))
           .granularity(QueryRunnerTestHelper.dayGran)
           .dimensionSpecs(DefaultDimensionSpec.toSpec(QueryRunnerTestHelper.qualityDimension))
@@ -557,7 +563,7 @@ public void testSelectWithFilterLookupExtractionFn()
     MapLookupExtractor mapLookupExtractor = new MapLookupExtractor(extractionMap, false);
     LookupExtractionFn lookupExtractionFn = new LookupExtractionFn(mapLookupExtractor, false, null, true, true);
     SelectQuery query = newTestQuery()
-        .intervals(I_0112_0114)
+        .intervals(I_0112_0114_SPEC)
         .filters(new SelectorDimFilter(QueryRunnerTestHelper.marketDimension, "replaced", lookupExtractionFn))
         .granularity(QueryRunnerTestHelper.dayGran)
         .dimensionSpecs(DefaultDimensionSpec.toSpec(QueryRunnerTestHelper.qualityDimension))
@@ -607,7 +613,7 @@ public void testSelectWithFilterLookupExtractionFn()
   public void testFullSelectNoResults()
   {
     SelectQuery query = newTestQuery()
-        .intervals(I_0112_0114)
+        .intervals(I_0112_0114_SPEC)
         .filters(
             new AndDimFilter(
                 Arrays.asList(
@@ -658,7 +664,7 @@ public void testFullSelectNoResults()
   public void testFullSelectNoDimensionAndMetric()
   {
     SelectQuery query = newTestQuery()
-        .intervals(I_0112_0114)
+        .intervals(I_0112_0114_SPEC)
         .dimensionSpecs(DefaultDimensionSpec.toSpec("foo"))
         .metrics(Collections.singletonList("foo2"))
         .build();
@@ -696,7 +702,7 @@ public void testFullOnSelectWithLongAndFloat()
     SelectQuery query = newTestQuery()
         .dimensionSpecs(dimSpecs)
         .metrics(Arrays.asList(Column.TIME_COLUMN_NAME, "index"))
-        .intervals(I_0112_0114)
+        .intervals(I_0112_0114_SPEC)
         .build();
 
     HashMap<String, Object> context = new HashMap<String, Object>();
@@ -811,7 +817,7 @@ public void testFullOnSelectWithLongAndFloatWithExFn()
     SelectQuery query = newTestQuery()
         .dimensionSpecs(dimSpecs)
         .metrics(Arrays.asList(Column.TIME_COLUMN_NAME, "index"))
-        .intervals(I_0112_0114)
+        .intervals(I_0112_0114_SPEC)
         .build();
 
     HashMap<String, Object> context = new HashMap<String, Object>();
diff --git a/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerTest.java
index 60bda9309cda..1a218b336839 100644
--- a/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerTest.java
@@ -636,7 +636,7 @@ public void testTimeseriesWithTimeZone()
                                       new PeriodGranularity(
                                           new Period("P1D"),
                                           null,
-                                          DateTimes.inferTzfromString("America/Los_Angeles")
+                                          DateTimes.inferTzFromString("America/Los_Angeles")
                                       )
                                   )
                                   .descending(descending)
@@ -644,13 +644,13 @@ public void testTimeseriesWithTimeZone()
 
     List<Result<TimeseriesResultValue>> expectedResults = Arrays.asList(
         new Result<>(
-            new DateTime("2011-03-31", DateTimes.inferTzfromString("America/Los_Angeles")),
+            new DateTime("2011-03-31", DateTimes.inferTzFromString("America/Los_Angeles")),
             new TimeseriesResultValue(
                 ImmutableMap.of("rows", 13L, "idx", 6619L)
             )
         ),
         new Result<>(
-            new DateTime("2011-04-01T", DateTimes.inferTzfromString("America/Los_Angeles")),
+            new DateTime("2011-04-01T", DateTimes.inferTzFromString("America/Los_Angeles")),
             new TimeseriesResultValue(
                 ImmutableMap.of("rows", 13L, "idx", 5827L)
             )
@@ -741,7 +741,7 @@ public void testTimeseriesGranularityNotAlignedOnSegmentBoundariesWithFilter()
                                        new PeriodGranularity(
                                            new Period("P7D"),
                                            null,
-                                           DateTimes.inferTzfromString("America/Los_Angeles")
+                                           DateTimes.inferTzFromString("America/Los_Angeles")
                                        )
                                    )
                                    .intervals(
@@ -763,13 +763,13 @@ public void testTimeseriesGranularityNotAlignedOnSegmentBoundariesWithFilter()
 
     List<Result<TimeseriesResultValue>> expectedResults1 = Arrays.asList(
         new Result<>(
-            new DateTime("2011-01-06T00:00:00.000-08:00", DateTimes.inferTzfromString("America/Los_Angeles")),
+            new DateTime("2011-01-06T00:00:00.000-08:00", DateTimes.inferTzFromString("America/Los_Angeles")),
             new TimeseriesResultValue(
                 ImmutableMap.of("rows", 13L, "idx", 6071L)
             )
         ),
         new Result<>(
-            new DateTime("2011-01-13T00:00:00.000-08:00", DateTimes.inferTzfromString("America/Los_Angeles")),
+            new DateTime("2011-01-13T00:00:00.000-08:00", DateTimes.inferTzFromString("America/Los_Angeles")),
             new TimeseriesResultValue(
                 ImmutableMap.of("rows", 91L, "idx", 33382L)
             )
diff --git a/processing/src/test/java/org/apache/druid/segment/filter/TimeFilteringTest.java b/processing/src/test/java/org/apache/druid/segment/filter/TimeFilteringTest.java
index d493b841ddcb..a286c78af5e0 100644
--- a/processing/src/test/java/org/apache/druid/segment/filter/TimeFilteringTest.java
+++ b/processing/src/test/java/org/apache/druid/segment/filter/TimeFilteringTest.java
@@ -227,7 +227,7 @@ public void testTimeFilterWithTimeFormatExtractionFn()
   {
     ExtractionFn exfn = new TimeFormatExtractionFn(
         "EEEE",
-        DateTimes.inferTzfromString("America/New_York"),
+        DateTimes.inferTzFromString("America/New_York"),
         "en",
         null,
         false
diff --git a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorCleanupOvershadowed.java b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorCleanupOvershadowed.java
index 6894934dbbf3..b09564bfd44e 100644
--- a/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorCleanupOvershadowed.java
+++ b/server/src/main/java/org/apache/druid/server/coordinator/helper/DruidCoordinatorCleanupOvershadowed.java
@@ -22,7 +22,6 @@
 import com.google.common.collect.Maps;
 import org.apache.druid.client.ImmutableDruidDataSource;
 import org.apache.druid.client.ImmutableDruidServer;
-import org.apache.druid.java.util.common.guava.Comparators;
 import org.apache.druid.server.coordinator.CoordinatorStats;
 import org.apache.druid.server.coordinator.DruidCluster;
 import org.apache.druid.server.coordinator.DruidCoordinator;
@@ -31,6 +30,7 @@
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 
+import java.util.Comparator;
 import java.util.Map;
 import java.util.SortedSet;
 
@@ -61,7 +61,7 @@ public DruidCoordinatorRuntimeParams run(DruidCoordinatorRuntimeParams params)
           for (ImmutableDruidDataSource dataSource : server.getDataSources()) {
             VersionedIntervalTimeline<String, DataSegment> timeline = timelines.get(dataSource.getName());
             if (timeline == null) {
-              timeline = new VersionedIntervalTimeline<>(Comparators.comparable());
+              timeline = new VersionedIntervalTimeline<>(Comparator.naturalOrder());
               timelines.put(dataSource.getName(), timeline);
             }
 
diff --git a/server/src/main/java/org/apache/druid/server/http/IntervalsResource.java b/server/src/main/java/org/apache/druid/server/http/IntervalsResource.java
index a3c3c5275b2f..b3f7cd3f0fc3 100644
--- a/server/src/main/java/org/apache/druid/server/http/IntervalsResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/IntervalsResource.java
@@ -69,7 +69,7 @@ public IntervalsResource(
   @Produces(MediaType.APPLICATION_JSON)
   public Response getIntervals(@Context final HttpServletRequest req)
   {
-    final Comparator<Interval> comparator = Comparators.inverse(Comparators.intervalsByStartThenEnd());
+    final Comparator<Interval> comparator = Comparators.intervalsByStartThenEnd().reversed();
     final Set<ImmutableDruidDataSource> datasources = InventoryViewUtils.getSecuredDataSources(
         req,
         serverInventoryView,
@@ -108,7 +108,7 @@ public Response getSpecificIntervals(
         authorizerMapper
     );
 
-    final Comparator<Interval> comparator = Comparators.inverse(Comparators.intervalsByStartThenEnd());
+    final Comparator<Interval> comparator = Comparators.intervalsByStartThenEnd().reversed();
 
     if (full != null) {
       final Map<Interval, Map<String, Map<String, Object>>> retVal = Maps.newTreeMap(comparator);
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
index 4dbbd8d6d86a..d97a514ae7d3 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
@@ -252,7 +252,7 @@ public class CachingClusteredClientTest
   private static final DimFilter DIM_FILTER = null;
   private static final List<PostAggregator> RENAMED_POST_AGGS = ImmutableList.of();
   private static final Granularity GRANULARITY = Granularities.DAY;
-  private static final DateTimeZone TIMEZONE = DateTimes.inferTzfromString("America/Los_Angeles");
+  private static final DateTimeZone TIMEZONE = DateTimes.inferTzFromString("America/Los_Angeles");
   private static final Granularity PT1H_TZ_GRANULARITY = new PeriodGranularity(new Period("PT1H"), null, TIMEZONE);
   private static final String TOP_DIM = "a_dim";
   private static final Supplier<SelectQueryConfig> SELECT_CONFIG_SUPPLIER = Suppliers.ofInstance(
diff --git a/server/src/test/java/org/apache/druid/segment/indexing/granularity/UniformGranularityTest.java b/server/src/test/java/org/apache/druid/segment/indexing/granularity/UniformGranularityTest.java
index ee5f43cf9799..ee03b7898add 100644
--- a/server/src/test/java/org/apache/druid/segment/indexing/granularity/UniformGranularityTest.java
+++ b/server/src/test/java/org/apache/druid/segment/indexing/granularity/UniformGranularityTest.java
@@ -239,7 +239,7 @@ spec, new UniformGranularitySpec(
   public void testPeriodSegmentGranularity()
   {
     final GranularitySpec spec = new UniformGranularitySpec(
-            new PeriodGranularity(new Period("P1D"), null, DateTimes.inferTzfromString("America/Los_Angeles")),
+            new PeriodGranularity(new Period("P1D"), null, DateTimes.inferTzFromString("America/Los_Angeles")),
             null,
             Lists.newArrayList(
                     Intervals.of("2012-01-08T00-08:00/2012-01-11T00-08:00"),
@@ -259,7 +259,7 @@ public void testPeriodSegmentGranularity()
       actualIntervals.add(interval.toDurationMillis());
     }
 
-    final ISOChronology chrono = ISOChronology.getInstance(DateTimes.inferTzfromString("America/Los_Angeles"));
+    final ISOChronology chrono = ISOChronology.getInstance(DateTimes.inferTzFromString("America/Los_Angeles"));
 
     final ArrayList<Long> expectedIntervals = Lists.newArrayList(
             new Interval("2012-01-01/2012-01-02", chrono).toDurationMillis(),
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeExtractOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeExtractOperatorConversion.java
index 07e054b538e8..e046dfe5fc9a 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeExtractOperatorConversion.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeExtractOperatorConversion.java
@@ -89,7 +89,7 @@ public DruidExpression toDruidExpression(
     );
 
     final DateTimeZone timeZone = call.getOperands().size() > 2 && !RexLiteral.isNullLiteral(call.getOperands().get(2))
-                                  ? DateTimes.inferTzfromString(RexLiteral.stringValue(call.getOperands().get(2)))
+                                  ? DateTimes.inferTzFromString(RexLiteral.stringValue(call.getOperands().get(2)))
                                   : plannerContext.getTimeZone();
 
     return applyTimeExtract(timeExpression, unit, timeZone);
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFloorOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFloorOperatorConversion.java
index ae98f5ed9862..0e74bd2290f9 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFloorOperatorConversion.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFloorOperatorConversion.java
@@ -141,7 +141,7 @@ public DruidExpression toDruidExpression(
           : null;
       final DateTimeZone timeZone =
           operands.size() > 3 && !RexLiteral.isNullLiteral(operands.get(3))
-          ? DateTimes.inferTzfromString(RexLiteral.stringValue(operands.get(3)))
+          ? DateTimes.inferTzFromString(RexLiteral.stringValue(operands.get(3)))
           : plannerContext.getTimeZone();
       final PeriodGranularity granularity = new PeriodGranularity(period, origin, timeZone);
       return applyTimestampFloor(druidExpressions.get(0), granularity, plannerContext.getExprMacroTable());
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFormatOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFormatOperatorConversion.java
index dbc452265631..b9d3b6711c7c 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFormatOperatorConversion.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFormatOperatorConversion.java
@@ -73,7 +73,7 @@ public DruidExpression toDruidExpression(
                            ? RexLiteral.stringValue(call.getOperands().get(1))
                            : "yyyy-MM-dd'T'HH:mm:ss.SSSZZ";
     final DateTimeZone timeZone = call.getOperands().size() > 2 && !RexLiteral.isNullLiteral(call.getOperands().get(2))
-                                  ? DateTimes.inferTzfromString(RexLiteral.stringValue(call.getOperands().get(2)))
+                                  ? DateTimes.inferTzFromString(RexLiteral.stringValue(call.getOperands().get(2)))
                                   : plannerContext.getTimeZone();
 
     return DruidExpression.fromFunctionCall(
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerContext.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerContext.java
index 2b088834af3d..cf05b6eb9b07 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerContext.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/PlannerContext.java
@@ -92,7 +92,7 @@ public static PlannerContext create(
       }
 
       if (tzParam != null) {
-        timeZone = DateTimes.inferTzfromString(String.valueOf(tzParam));
+        timeZone = DateTimes.inferTzFromString(String.valueOf(tzParam));
       } else {
         timeZone = plannerConfig.getSqlTimeZone();
       }
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
index be673420d41e..b2d377f1c5c5 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
@@ -274,7 +274,7 @@ public void testTimestampsInResponseLosAngelesTimeZone() throws Exception
         "SELECT __time, CAST(__time AS DATE) AS t2 FROM druid.foo LIMIT 1"
     );
 
-    final DateTimeZone timeZone = DateTimes.inferTzfromString("America/Los_Angeles");
+    final DateTimeZone timeZone = DateTimes.inferTzFromString("America/Los_Angeles");
     final DateTime localDateTime = new DateTime("2000-01-01T00Z", timeZone);
 
     final List<Map<String, Object>> resultRows = getRows(resultSet);
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java
index 8f9e0d406635..cdc2c7f829cd 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java
@@ -185,7 +185,7 @@ public int getMaxQueryCount()
     @Override
     public DateTimeZone getSqlTimeZone()
     {
-      return DateTimes.inferTzfromString("America/Los_Angeles");
+      return DateTimes.inferTzFromString("America/Los_Angeles");
     }
   };
   private static final PlannerConfig PLANNER_CONFIG_SEMI_JOIN_ROWS_LIMIT = new PlannerConfig()
@@ -6079,7 +6079,7 @@ public void testTimeseriesLosAngelesViaQueryContext() throws Exception
             Druids.newTimeseriesQueryBuilder()
                   .dataSource(CalciteTests.DATASOURCE1)
                   .intervals(QSS(Filtration.eternity()))
-                  .granularity(new PeriodGranularity(Period.months(1), null, DateTimes.inferTzfromString(LOS_ANGELES)))
+                  .granularity(new PeriodGranularity(Period.months(1), null, DateTimes.inferTzFromString(LOS_ANGELES)))
                   .aggregators(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
                   .context(TIMESERIES_CONTEXT_LOS_ANGELES)
                   .build()
@@ -6110,7 +6110,7 @@ public void testTimeseriesLosAngelesViaPlannerConfig() throws Exception
             Druids.newTimeseriesQueryBuilder()
                   .dataSource(CalciteTests.DATASOURCE1)
                   .intervals(QSS(Filtration.eternity()))
-                  .granularity(new PeriodGranularity(Period.months(1), null, DateTimes.inferTzfromString(LOS_ANGELES)))
+                  .granularity(new PeriodGranularity(Period.months(1), null, DateTimes.inferTzFromString(LOS_ANGELES)))
                   .aggregators(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
                   .context(TIMESERIES_CONTEXT_DEFAULT)
                   .build()
@@ -6294,7 +6294,7 @@ public void testTimeseriesLosAngelesUsingTimeFloorConnectionUtc() throws Excepti
             Druids.newTimeseriesQueryBuilder()
                   .dataSource(CalciteTests.DATASOURCE1)
                   .intervals(QSS(Filtration.eternity()))
-                  .granularity(new PeriodGranularity(Period.months(1), null, DateTimes.inferTzfromString(LOS_ANGELES)))
+                  .granularity(new PeriodGranularity(Period.months(1), null, DateTimes.inferTzFromString(LOS_ANGELES)))
                   .aggregators(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
                   .context(TIMESERIES_CONTEXT_DEFAULT)
                   .build()
@@ -6325,7 +6325,7 @@ public void testTimeseriesLosAngelesUsingTimeFloorConnectionLosAngeles() throws
             Druids.newTimeseriesQueryBuilder()
                   .dataSource(CalciteTests.DATASOURCE1)
                   .intervals(QSS(Filtration.eternity()))
-                  .granularity(new PeriodGranularity(Period.months(1), null, DateTimes.inferTzfromString(LOS_ANGELES)))
+                  .granularity(new PeriodGranularity(Period.months(1), null, DateTimes.inferTzFromString(LOS_ANGELES)))
                   .aggregators(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
                   .context(TIMESERIES_CONTEXT_LOS_ANGELES)
                   .build()
@@ -7581,7 +7581,7 @@ private static long T(final String timeString)
   // Generate timestamps for expected results
   private static long T(final String timeString, final String timeZoneString)
   {
-    final DateTimeZone timeZone = DateTimes.inferTzfromString(timeZoneString);
+    final DateTimeZone timeZone = DateTimes.inferTzFromString(timeZoneString);
     return Calcites.jodaToCalciteTimestamp(new DateTime(timeString, timeZone), timeZone);
   }
 
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
index f7db35d3fe5c..23a29472ad87 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
@@ -66,7 +66,7 @@
 
 public class ExpressionsTest extends CalciteTestBase
 {
-  private static final DateTimeZone LOS_ANGELES = DateTimes.inferTzfromString("America/Los_Angeles");
+  private static final DateTimeZone LOS_ANGELES = DateTimes.inferTzFromString("America/Los_Angeles");
 
   private final PlannerContext plannerContext = PlannerContext.create(
       CalciteTests.createOperatorTable(),

From 3be105cc79a9318bada53dc1e83e06b720656df7 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Fri, 28 Sep 2018 12:51:49 +0300
Subject: [PATCH 03/27] Fix SelectQueryRunnerTest

---
 .../benchmark/query/SelectBenchmark.java      |  6 +-
 .../DistinctCountGroupByQueryTest.java        |  2 +-
 .../DistinctCountTimeseriesQueryTest.java     |  2 +-
 .../DistinctCountTopNQueryTest.java           |  2 +-
 .../MaterializedViewQueryTest.java            |  6 +-
 .../druid/segment/MapVirtualColumnTest.java   |  2 +-
 .../ApproximateHistogramGroupByQueryTest.java |  4 +-
 .../ApproximateHistogramTopNQueryTest.java    |  2 +-
 .../variance/VarianceTopNQueryTest.java       |  2 +-
 .../common/granularity/Granularities.java     |  2 +-
 .../apache/druid/query/UnionDataSource.java   | 15 +---
 .../druid/query/DefaultQueryMetricsTest.java  |  4 +-
 .../apache/druid/query/DoubleStorageTest.java |  2 +-
 .../druid/query/MultiValuedDimensionTest.java |  2 +-
 .../druid/query/QueryRunnerTestHelper.java    | 18 ++--
 .../first/StringFirstTimeseriesQueryTest.java |  2 +-
 .../last/StringLastTimeseriesQueryTest.java   |  2 +-
 .../query/groupby/GroupByQueryRunnerTest.java | 50 +++++------
 .../GroupByTimeseriesQueryRunnerTest.java     |  2 +-
 .../SegmentMetadataUnionQueryTest.java        |  2 +-
 .../druid/query/scan/ScanQueryRunnerTest.java |  2 +-
 .../search/DefaultSearchQueryMetricsTest.java |  6 +-
 .../query/search/SearchQueryRunnerTest.java   | 54 ++++++------
 .../search/SearchQueryRunnerWithCaseTest.java |  4 +-
 .../druid/query/search/SearchQueryTest.java   |  8 +-
 .../select/DefaultSelectQueryMetricsTest.java |  6 +-
 .../query/select/SelectQueryRunnerTest.java   | 49 +++++++----
 .../DefaultTimeseriesQueryMetricsTest.java    |  4 +-
 .../timeseries/TimeseriesQueryRunnerTest.java | 12 +--
 .../query/timeseries/TimeseriesQueryTest.java |  2 +-
 .../topn/DefaultTopNQueryMetricsTest.java     |  4 +-
 .../topn/TopNQueryQueryToolChestTest.java     |  2 +-
 .../query/topn/TopNQueryRunnerBenchmark.java  |  2 +-
 .../druid/query/topn/TopNQueryRunnerTest.java | 88 +++++++++----------
 .../druid/query/topn/TopNQueryTest.java       |  8 +-
 .../druid/query/topn/TopNUnionQueryTest.java  |  2 +-
 36 files changed, 193 insertions(+), 189 deletions(-)

diff --git a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SelectBenchmark.java b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SelectBenchmark.java
index b1437f3b1ddb..7a0f8e00b554 100644
--- a/benchmarks/src/main/java/org/apache/druid/benchmark/query/SelectBenchmark.java
+++ b/benchmarks/src/main/java/org/apache/druid/benchmark/query/SelectBenchmark.java
@@ -272,8 +272,10 @@ private static <T> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runn
     return queryResult.toList();
   }
 
-  // don't run this benchmark with a query that doesn't use QueryGranularities.ALL,
-  // this pagination function probably doesn't work correctly in that case.
+  /**
+   * Don't run this benchmark with a query that doesn't use {@link Granularities#ALL},
+   * this pagination function probably doesn't work correctly in that case.
+   */
   private SelectQuery incrementQueryPagination(SelectQuery query, SelectResultValue prevResult)
   {
     Map<String, Integer> pagingIdentifiers = prevResult.getPagingIdentifiers();
diff --git a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountGroupByQueryTest.java b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountGroupByQueryTest.java
index 886826871c56..dc4f1daca48b 100644
--- a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountGroupByQueryTest.java
+++ b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountGroupByQueryTest.java
@@ -119,7 +119,7 @@ public void testGroupByWithDistinctCountAgg() throws Exception
             client_type,
             client_type
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(new OrderByColumnSpec(client_type, OrderByColumnSpec.Direction.DESCENDING)),
diff --git a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTimeseriesQueryTest.java b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTimeseriesQueryTest.java
index 7d8fb98db953..127fa9be4938 100644
--- a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTimeseriesQueryTest.java
+++ b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTimeseriesQueryTest.java
@@ -88,7 +88,7 @@ public void testTopNWithDistinctCountAgg() throws Exception
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(QueryRunnerTestHelper.allGran)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       Lists.newArrayList(
                                           QueryRunnerTestHelper.rowsCount,
diff --git a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTopNQueryTest.java b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTopNQueryTest.java
index e9e4dea3ec8f..f7b12ce21c09 100644
--- a/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTopNQueryTest.java
+++ b/extensions-contrib/distinctcount/src/test/java/org/apache/druid/query/aggregation/distinctcount/DistinctCountTopNQueryTest.java
@@ -117,7 +117,7 @@ public void testTopNWithDistinctCountAgg() throws Exception
 
     TopNQuery query = new TopNQueryBuilder().dataSource(QueryRunnerTestHelper.dataSource)
                           .granularity(QueryRunnerTestHelper.allGran)
-                          .intervals(QueryRunnerTestHelper.fullOnInterval)
+                          .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                           .dimension(client_type)
                           .metric("UV")
                           .threshold(10)
diff --git a/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewQueryTest.java b/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewQueryTest.java
index 39c0c8276fa2..3cfe6b806477 100644
--- a/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewQueryTest.java
+++ b/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewQueryTest.java
@@ -30,7 +30,7 @@
 import static org.apache.druid.query.QueryRunnerTestHelper.allGran;
 import static org.apache.druid.query.QueryRunnerTestHelper.commonDoubleAggregators;
 import static org.apache.druid.query.QueryRunnerTestHelper.dataSource;
-import static org.apache.druid.query.QueryRunnerTestHelper.fullOnInterval;
+import static org.apache.druid.query.QueryRunnerTestHelper.fullOnIntervalSpec;
 import static org.apache.druid.query.QueryRunnerTestHelper.indexMetric;
 import static org.apache.druid.query.QueryRunnerTestHelper.marketDimension;
 import org.apache.druid.query.TableDataSource;
@@ -74,7 +74,7 @@ public void testQuerySerialization() throws IOException
         .dimension(marketDimension)
         .metric(indexMetric)
         .threshold(4)
-        .intervals(fullOnInterval)
+        .intervals(fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -94,6 +94,6 @@ public void testQuerySerialization() throws IOException
     Assert.assertEquals(query, serdeQuery);
     Assert.assertEquals(new TableDataSource(dataSource), query.getDataSource());
     Assert.assertEquals(allGran, query.getGranularity());
-    Assert.assertEquals(fullOnInterval.getIntervals(), query.getIntervals());
+    Assert.assertEquals(fullOnIntervalSpec.getIntervals(), query.getIntervals());
   }
 }
diff --git a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTest.java b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTest.java
index 9a9aa86aade8..14b151cf6c82 100644
--- a/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTest.java
+++ b/extensions-contrib/virtual-columns/src/test/java/org/apache/druid/segment/MapVirtualColumnTest.java
@@ -138,7 +138,7 @@ private Druids.SelectQueryBuilder testBuilder()
     return Druids.newSelectQueryBuilder()
                  .dataSource(QueryRunnerTestHelper.dataSource)
                  .granularity(QueryRunnerTestHelper.allGran)
-                 .intervals(QueryRunnerTestHelper.fullOnInterval)
+                 .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                  .pagingSpec(new PagingSpec(null, 3));
   }
 
diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramGroupByQueryTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramGroupByQueryTest.java
index ff81674a77a8..c366ed5031ac 100644
--- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramGroupByQueryTest.java
+++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramGroupByQueryTest.java
@@ -174,7 +174,7 @@ public void testGroupByWithApproximateHistogramAgg()
             QueryRunnerTestHelper.marketDimension,
             "marketalias"
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(new OrderByColumnSpec("marketalias", OrderByColumnSpec.Direction.DESCENDING)),
@@ -233,7 +233,7 @@ public void testGroupByWithSameNameComplexPostAgg()
             QueryRunnerTestHelper.marketDimension,
             "marketalias"
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(new OrderByColumnSpec("marketalias", OrderByColumnSpec.Direction.DESCENDING)),
diff --git a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramTopNQueryTest.java b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramTopNQueryTest.java
index f0bd1de94a21..5bac2ac8a0a8 100644
--- a/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramTopNQueryTest.java
+++ b/extensions-core/histogram/src/test/java/org/apache/druid/query/aggregation/histogram/ApproximateHistogramTopNQueryTest.java
@@ -127,7 +127,7 @@ public void testTopNWithApproximateHistogramAgg()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.dependentPostAggMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
diff --git a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTopNQueryTest.java b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTopNQueryTest.java
index a8c43969c815..e634b67984b6 100644
--- a/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTopNQueryTest.java
+++ b/extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/VarianceTopNQueryTest.java
@@ -73,7 +73,7 @@ public void testFullOnTopNOverUniques()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.uniqueMetric)
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
diff --git a/java-util/src/main/java/org/apache/druid/java/util/common/granularity/Granularities.java b/java-util/src/main/java/org/apache/druid/java/util/common/granularity/Granularities.java
index fcc4afffa762..91492aef7173 100644
--- a/java-util/src/main/java/org/apache/druid/java/util/common/granularity/Granularities.java
+++ b/java-util/src/main/java/org/apache/druid/java/util/common/granularity/Granularities.java
@@ -20,7 +20,7 @@
 package org.apache.druid.java.util.common.granularity;
 
 /**
- * This class was created b/c sometimes  static initializers of a class that use a subclass can deadlock.
+ * This class was created b/c sometimes static initializers of a class that use a subclass can deadlock.
  * See: #2979, #3979
  */
 public class Granularities
diff --git a/processing/src/main/java/org/apache/druid/query/UnionDataSource.java b/processing/src/main/java/org/apache/druid/query/UnionDataSource.java
index a48bbf0f06b5..290ac538b0af 100644
--- a/processing/src/main/java/org/apache/druid/query/UnionDataSource.java
+++ b/processing/src/main/java/org/apache/druid/query/UnionDataSource.java
@@ -22,12 +22,11 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.google.common.base.Function;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
 
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class UnionDataSource implements DataSource
 {
@@ -44,17 +43,7 @@ public UnionDataSource(@JsonProperty("dataSources") List<TableDataSource> dataSo
   @Override
   public List<String> getNames()
   {
-    return Lists.transform(
-        dataSources,
-        new Function<TableDataSource, String>()
-        {
-          @Override
-          public String apply(TableDataSource input)
-          {
-            return Iterables.getOnlyElement(input.getNames());
-          }
-        }
-    );
+    return dataSources.stream().map(input -> Iterables.getOnlyElement(input.getNames())).collect(Collectors.toList());
   }
 
   @JsonProperty
diff --git a/processing/src/test/java/org/apache/druid/query/DefaultQueryMetricsTest.java b/processing/src/test/java/org/apache/druid/query/DefaultQueryMetricsTest.java
index ac022cacfffa..fe8f0201a252 100644
--- a/processing/src/test/java/org/apache/druid/query/DefaultQueryMetricsTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DefaultQueryMetricsTest.java
@@ -60,7 +60,7 @@ public void testDefaultQueryMetricsQuery()
             null
         ))
         .metric("count")
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(Collections.singletonList(new CountAggregatorFactory("count")))
         .threshold(5)
         .filters(new SelectorDimFilter("tags", "t3", null))
@@ -75,7 +75,7 @@ public void testDefaultQueryMetricsQuery()
     Assert.assertEquals("", actualEvent.get("service"));
     Assert.assertEquals("xx", actualEvent.get(DruidMetrics.DATASOURCE));
     Assert.assertEquals(query.getType(), actualEvent.get(DruidMetrics.TYPE));
-    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnInterval.getIntervals();
+    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnIntervalSpec.getIntervals();
     List<String> expectedStringIntervals =
         expectedIntervals.stream().map(Interval::toString).collect(Collectors.toList());
     Assert.assertEquals(expectedStringIntervals, actualEvent.get(DruidMetrics.INTERVAL));
diff --git a/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java b/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
index 49ef192703e3..00791e8944e5 100644
--- a/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
@@ -102,7 +102,7 @@ private ScanQuery.ScanQueryBuilder newTestQuery()
     return ScanQuery.newScanQueryBuilder()
                     .dataSource(new TableDataSource(QueryRunnerTestHelper.dataSource))
                     .columns(Collections.emptyList())
-                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                     .limit(Integer.MAX_VALUE)
                     .legacy(false);
   }
diff --git a/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java b/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
index 0bb120242e96..37a73da76d1d 100644
--- a/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
+++ b/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
@@ -261,7 +261,7 @@ public void testTopNWithDimFilterAndWithFilteredDimSpec()
             null
         ))
         .metric("count")
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(Collections.singletonList(new CountAggregatorFactory("count")))
         .threshold(5)
         .filters(new SelectorDimFilter("tags", "t3", null)).build();
diff --git a/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java b/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
index dbe3dfbe77d5..40db24234984 100644
--- a/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
+++ b/processing/src/test/java/org/apache/druid/query/QueryRunnerTestHelper.java
@@ -75,6 +75,8 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  */
@@ -83,10 +85,11 @@ public class QueryRunnerTestHelper
 
   public static final QueryWatcher NOOP_QUERYWATCHER = (query, future) -> {};
 
-  public static final SegmentId segmentId = SegmentId.dummy("testSegment");
   public static final String dataSource = "testing";
+  public static final Interval fullOnInterval = Intervals.of("1970-01-01T00:00:00.000Z/2020-01-01T00:00:00.000Z");
+  public static final SegmentId segmentId = SegmentId.of(dataSource, fullOnInterval, "dummy_version", 0);
   public static final UnionDataSource unionDataSource = new UnionDataSource(
-      Lists.transform(Lists.newArrayList(dataSource, dataSource, dataSource, dataSource), TableDataSource::new)
+      Stream.of(dataSource, dataSource, dataSource, dataSource).map(TableDataSource::new).collect(Collectors.toList())
   );
 
   public static final Granularity dayGran = Granularities.DAY;
@@ -228,7 +231,7 @@ public class QueryRunnerTestHelper
   public static final String[] expectedFullOnIndexValuesDesc;
 
   static {
-    List<String> list = new ArrayList(Arrays.asList(expectedFullOnIndexValues));
+    List<String> list = new ArrayList<>(Arrays.asList(expectedFullOnIndexValues));
     Collections.reverse(list);
     expectedFullOnIndexValuesDesc = list.toArray(new String[0]);
   }
@@ -244,8 +247,9 @@ public class QueryRunnerTestHelper
   public static final QuerySegmentSpec secondOnly = new MultipleIntervalSegmentSpec(
       Collections.singletonList(Intervals.of("2011-04-02T00:00:00.000Z/P1D"))
   );
-  public static final QuerySegmentSpec fullOnInterval = new MultipleIntervalSegmentSpec(
-      Collections.singletonList(Intervals.of("1970-01-01T00:00:00.000Z/2020-01-01T00:00:00.000Z"))
+
+  public static final QuerySegmentSpec fullOnIntervalSpec = new MultipleIntervalSegmentSpec(
+      Collections.singletonList(fullOnInterval)
   );
   public static final QuerySegmentSpec emptyInterval = new MultipleIntervalSegmentSpec(
       Collections.singletonList(Intervals.of("2020-04-02T00:00:00.000Z/P1D"))
@@ -349,9 +353,7 @@ public static <T, QueryType extends Query<T>> List<QueryRunner<T>> makeQueryRunn
   }
 
   @SuppressWarnings("unchecked")
-  public static Collection<?> makeUnionQueryRunners(
-      QueryRunnerFactory factory
-  )
+  public static Collection<?> makeUnionQueryRunners(QueryRunnerFactory factory)
   {
     final IncrementalIndex rtIndex = TestIndex.getIncrementalTestIndex();
     final QueryableIndex mMappedTestIndex = TestIndex.getMMappedTestIndex();
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/first/StringFirstTimeseriesQueryTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/first/StringFirstTimeseriesQueryTest.java
index d9c8a112b81e..df1bce849880 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/first/StringFirstTimeseriesQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/first/StringFirstTimeseriesQueryTest.java
@@ -97,7 +97,7 @@ public void testTopNWithDistinctCountAgg() throws Exception
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(QueryRunnerTestHelper.allGran)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       Collections.singletonList(
                                           new StringFirstAggregatorFactory(
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/last/StringLastTimeseriesQueryTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/last/StringLastTimeseriesQueryTest.java
index 6fef95f98699..aa31c0ade4b2 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/last/StringLastTimeseriesQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/last/StringLastTimeseriesQueryTest.java
@@ -97,7 +97,7 @@ public void testTopNWithDistinctCountAgg() throws Exception
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(QueryRunnerTestHelper.allGran)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       Collections.singletonList(
                                           new StringLastAggregatorFactory(
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
index dda2e47e34aa..814f4d2475f0 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
@@ -1515,7 +1515,7 @@ public void testSubqueryWithOuterMaxOnDiskStorageContextOverride()
     final GroupByQuery subquery = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("quality", "alias"))
         .setGranularity(QueryRunnerTestHelper.dayGran)
         .setLimitSpec(
@@ -1979,7 +1979,7 @@ public void testGroupByWithFirstLast()
     GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("market", "market"))
         .setAggregatorSpecs(new LongFirstAggregatorFactory("first", "index"),
                             new LongLastAggregatorFactory("last", "index"))
@@ -2873,7 +2873,7 @@ public void testGroupByWithSameCaseOrdering()
             QueryRunnerTestHelper.marketDimension,
             "marketalias"
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(new OrderByColumnSpec("marketalias", OrderByColumnSpec.Direction.DESCENDING)),
@@ -2920,7 +2920,7 @@ public void testGroupByWithOrderLimit4()
             QueryRunnerTestHelper.marketDimension,
             QueryRunnerTestHelper.marketDimension
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(
@@ -2957,7 +2957,7 @@ public void testGroupByWithOrderOnHyperUnique()
             QueryRunnerTestHelper.marketDimension,
             QueryRunnerTestHelper.marketDimension
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(
@@ -3020,7 +3020,7 @@ public void testGroupByWithHavingOnHyperUnique()
             QueryRunnerTestHelper.marketDimension,
             QueryRunnerTestHelper.marketDimension
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(
@@ -3067,7 +3067,7 @@ public void testGroupByWithHavingOnFinalizedHyperUnique()
             QueryRunnerTestHelper.marketDimension,
             QueryRunnerTestHelper.marketDimension
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(
@@ -3116,7 +3116,7 @@ public void testGroupByWithLimitOnFinalizedHyperUnique()
             QueryRunnerTestHelper.marketDimension,
             QueryRunnerTestHelper.marketDimension
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(
@@ -4323,7 +4323,7 @@ public void testGroupByTimeExtractionNamedUnderUnderTime()
     GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("market", "market"), new ExtractionDimensionSpec(
             Column.TIME_COLUMN_NAME,
             Column.TIME_COLUMN_NAME,
@@ -5065,7 +5065,7 @@ public void testSubqueryWithOuterFilterAggregator()
     final GroupByQuery subquery = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("market", "market"), new DefaultDimensionSpec("quality", "quality"))
         .setAggregatorSpecs(QueryRunnerTestHelper.rowsCount, new LongSumAggregatorFactory("index", "index"))
         .setGranularity(QueryRunnerTestHelper.dayGran)
@@ -5075,7 +5075,7 @@ public void testSubqueryWithOuterFilterAggregator()
     final GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(subquery)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(Lists.newArrayList())
         .setAggregatorSpecs(new FilteredAggregatorFactory(QueryRunnerTestHelper.rowsCount, filter))
         .setGranularity(QueryRunnerTestHelper.allGran)
@@ -5094,7 +5094,7 @@ public void testSubqueryWithOuterTimeFilter()
     final GroupByQuery subquery = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("market", "market"), new DefaultDimensionSpec("quality", "quality"))
         .setAggregatorSpecs(QueryRunnerTestHelper.rowsCount, new LongSumAggregatorFactory("index", "index"))
         .setGranularity(QueryRunnerTestHelper.dayGran)
@@ -5105,7 +5105,7 @@ public void testSubqueryWithOuterTimeFilter()
     final GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(subquery)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(Lists.newArrayList())
         .setDimFilter(firstDaysFilter)
         .setAggregatorSpecs(new FilteredAggregatorFactory(QueryRunnerTestHelper.rowsCount, fridayFilter))
@@ -5133,7 +5133,7 @@ public void testSubqueryWithContextTimeout()
     final GroupByQuery subquery = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("quality", "alias"))
         .setGranularity(QueryRunnerTestHelper.dayGran)
         .build();
@@ -5160,7 +5160,7 @@ public void testSubqueryWithOuterVirtualColumns()
     final GroupByQuery subquery = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("quality", "alias"))
         .setGranularity(QueryRunnerTestHelper.dayGran)
         .build();
@@ -5187,7 +5187,7 @@ public void testSubqueryWithOuterCardinalityAggregator()
     final GroupByQuery subquery = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("market", "market"), new DefaultDimensionSpec("quality", "quality"))
         .setAggregatorSpecs(QueryRunnerTestHelper.rowsCount, new LongSumAggregatorFactory("index", "index"))
         .setGranularity(QueryRunnerTestHelper.dayGran)
@@ -5196,7 +5196,7 @@ public void testSubqueryWithOuterCardinalityAggregator()
     final GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(subquery)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(Lists.newArrayList()).setAggregatorSpecs(new CardinalityAggregatorFactory(
             "car",
             ImmutableList.of(new DefaultDimensionSpec(
@@ -5221,7 +5221,7 @@ public void testSubqueryWithOuterCountAggregator()
     final GroupByQuery subquery = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("quality", "alias"))
         .setGranularity(QueryRunnerTestHelper.dayGran)
         .setLimitSpec(
@@ -5556,7 +5556,7 @@ public void testSubqueryWithFirstLast()
     GroupByQuery subquery = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("market", "market"))
         .setAggregatorSpecs(QueryRunnerTestHelper.rowsCount,
                             new LongFirstAggregatorFactory("innerfirst", "index"),
@@ -5568,7 +5568,7 @@ public void testSubqueryWithFirstLast()
     GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(subquery)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(Lists.newArrayList())
         .setAggregatorSpecs(new LongFirstAggregatorFactory("first", "innerfirst"),
                             new LongLastAggregatorFactory("last", "innerlast"))
@@ -5809,7 +5809,7 @@ public void testGroupByTimeExtraction()
     GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("market", "market"), new ExtractionDimensionSpec(
             Column.TIME_COLUMN_NAME,
             "dayOfWeek",
@@ -6054,7 +6054,7 @@ public ExtractionType getExtractionType()
     GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(QueryRunnerTestHelper.dataSource)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnInterval)
+        .setQuerySegmentSpec(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setDimensions(new DefaultDimensionSpec("market", "market"), new ExtractionDimensionSpec(
             Column.TIME_COLUMN_NAME,
             "dayOfWeek",
@@ -8184,7 +8184,7 @@ public void testGroupByLimitPushDown()
             QueryRunnerTestHelper.marketDimension,
             "marketalias"
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(new OrderByColumnSpec(
@@ -8521,7 +8521,7 @@ public void testGroupByLimitPushDownPostAggNotSupported()
             QueryRunnerTestHelper.marketDimension,
             "marketalias"
         ))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(new OrderByColumnSpec(
@@ -8664,7 +8664,7 @@ public void testRejectForceLimitPushDownWithHaving()
         .setDataSource(QueryRunnerTestHelper.dataSource)
         .setGranularity(QueryRunnerTestHelper.allGran)
         .setDimensions(new DefaultDimensionSpec(QueryRunnerTestHelper.marketDimension, "marketalias"))
-        .setInterval(QueryRunnerTestHelper.fullOnInterval)
+        .setInterval(QueryRunnerTestHelper.fullOnIntervalSpec)
         .setLimitSpec(
             new DefaultLimitSpec(
                 Collections.singletonList(new OrderByColumnSpec("marketalias", OrderByColumnSpec.Direction.DESCENDING)),
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByTimeseriesQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByTimeseriesQueryRunnerTest.java
index 06a3e5eec037..cb57b097a439 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByTimeseriesQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByTimeseriesQueryRunnerTest.java
@@ -156,7 +156,7 @@ public void testFullOnTimeseriesMaxMin()
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(Granularities.ALL)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       new DoubleMaxAggregatorFactory("maxIndex", "index"),
                                       new DoubleMinAggregatorFactory("minIndex", "index")
diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java
index e8e60b99bc16..e867ee04cf4e 100644
--- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataUnionQueryTest.java
@@ -114,7 +114,7 @@ public void testSegmentMetadataUnionQuery()
     );
     SegmentMetadataQuery query = new Druids.SegmentMetadataQueryBuilder()
         .dataSource(QueryRunnerTestHelper.unionDataSource)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .toInclude(new ListColumnIncluderator(Collections.singletonList("placement")))
         .analysisTypes(
             SegmentMetadataQuery.AnalysisType.CARDINALITY,
diff --git a/processing/src/test/java/org/apache/druid/query/scan/ScanQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/scan/ScanQueryRunnerTest.java
index 226f2961c225..dab6f6450ae0 100644
--- a/processing/src/test/java/org/apache/druid/query/scan/ScanQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/scan/ScanQueryRunnerTest.java
@@ -142,7 +142,7 @@ private ScanQuery.ScanQueryBuilder newTestQuery()
     return ScanQuery.newScanQueryBuilder()
                     .dataSource(new TableDataSource(QueryRunnerTestHelper.dataSource))
                     .columns(Collections.emptyList())
-                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                     .limit(3)
                     .legacy(legacy);
   }
diff --git a/processing/src/test/java/org/apache/druid/query/search/DefaultSearchQueryMetricsTest.java b/processing/src/test/java/org/apache/druid/query/search/DefaultSearchQueryMetricsTest.java
index d0378ea2d2ba..d3f4ee1fefa8 100644
--- a/processing/src/test/java/org/apache/druid/query/search/DefaultSearchQueryMetricsTest.java
+++ b/processing/src/test/java/org/apache/druid/query/search/DefaultSearchQueryMetricsTest.java
@@ -51,7 +51,7 @@ public void testDefaultSearchQueryMetricsQuery()
         .newSearchQueryBuilder()
         .dataSource(QueryRunnerTestHelper.dataSource)
         .granularity(QueryRunnerTestHelper.dayGran)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .dimensions(new ListFilteredDimensionSpec(
             new DefaultDimensionSpec("tags", "tags"),
             ImmutableSet.of("t3"),
@@ -72,7 +72,7 @@ public void testDefaultSearchQueryMetricsQuery()
     Assert.assertEquals("", actualEvent.get("service"));
     Assert.assertEquals(QueryRunnerTestHelper.dataSource, actualEvent.get(DruidMetrics.DATASOURCE));
     Assert.assertEquals(query.getType(), actualEvent.get(DruidMetrics.TYPE));
-    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnInterval.getIntervals();
+    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnIntervalSpec.getIntervals();
     List<String> expectedStringIntervals =
         expectedIntervals.stream().map(Interval::toString).collect(Collectors.toList());
     Assert.assertEquals(expectedStringIntervals, actualEvent.get(DruidMetrics.INTERVAL));
@@ -92,7 +92,7 @@ public void testDefaultSearchQueryMetricsMetricNamesAndUnits()
         .newSearchQueryBuilder()
         .dataSource(QueryRunnerTestHelper.dataSource)
         .granularity(QueryRunnerTestHelper.dayGran)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .build();
 
     CachingEmitter cachingEmitter = new CachingEmitter();
diff --git a/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerTest.java
index cc1876a4c9d1..8badba6fcca2 100644
--- a/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerTest.java
@@ -132,7 +132,7 @@ public void testSearch()
     SearchQuery searchQuery = Druids.newSearchQueryBuilder()
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .query("a")
                                     .build();
 
@@ -155,7 +155,7 @@ public void testSearchWithCardinality()
     final SearchQuery searchQuery = Druids.newSearchQueryBuilder()
                                           .dataSource(QueryRunnerTestHelper.dataSource)
                                           .granularity(QueryRunnerTestHelper.allGran)
-                                          .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                          .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                           .query("a")
                                           .build();
 
@@ -198,7 +198,7 @@ public void testSearchSameValueInMultiDims()
     SearchQuery searchQuery = Druids.newSearchQueryBuilder()
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .dimensions(
                                         Arrays.asList(
                                             QueryRunnerTestHelper.placementDimension,
@@ -222,7 +222,7 @@ public void testSearchSameValueInMultiDims2()
     SearchQuery searchQuery = Druids.newSearchQueryBuilder()
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .dimensions(
                                         Arrays.asList(
                                             QueryRunnerTestHelper.placementDimension,
@@ -247,7 +247,7 @@ public void testFragmentSearch()
     SearchQuery searchQuery = Druids.newSearchQueryBuilder()
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .query(new FragmentSearchQuerySpec(Arrays.asList("auto", "ve")))
                                     .build();
 
@@ -272,7 +272,7 @@ public void testSearchWithDimensionQuality()
               .dataSource(QueryRunnerTestHelper.dataSource)
               .granularity(QueryRunnerTestHelper.allGran)
               .dimensions("quality")
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .query("a")
               .build(),
         expectedHits
@@ -290,7 +290,7 @@ public void testSearchWithDimensionProvider()
               .dataSource(QueryRunnerTestHelper.dataSource)
               .granularity(QueryRunnerTestHelper.allGran)
               .dimensions("market")
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .query("a")
               .build(),
         expectedHits
@@ -318,7 +318,7 @@ public void testSearchWithDimensionsQualityAndProvider()
                       QueryRunnerTestHelper.marketDimension
                   )
               )
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .query("a")
               .build(),
         expectedHits
@@ -341,7 +341,7 @@ public void testSearchWithDimensionsPlacementAndProvider()
                       QueryRunnerTestHelper.marketDimension
                   )
               )
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .query("mark")
               .build(),
         expectedHits
@@ -375,7 +375,7 @@ public void testSearchWithExtractionFilter1()
                                       null
                                   )
                               )
-                              .intervals(QueryRunnerTestHelper.fullOnInterval)
+                              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                               .dimensions(
                                   new ExtractionDimensionSpec(
                                       QueryRunnerTestHelper.qualityDimension,
@@ -405,7 +405,7 @@ public void testSearchWithSingleFilter1()
                           new SelectorDimFilter(QueryRunnerTestHelper.marketDimension, "total_market", null),
                           new SelectorDimFilter(QueryRunnerTestHelper.qualityDimension, "mezzanine", null)
                       )))
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .dimensions(QueryRunnerTestHelper.qualityDimension)
               .query("a")
               .build(),
@@ -424,7 +424,7 @@ public void testSearchWithSingleFilter2()
               .dataSource(QueryRunnerTestHelper.dataSource)
               .granularity(QueryRunnerTestHelper.allGran)
               .filters(QueryRunnerTestHelper.marketDimension, "total_market")
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .dimensions(QueryRunnerTestHelper.marketDimension)
               .query("a")
               .build(),
@@ -449,7 +449,7 @@ public void testSearchMultiAndFilter()
               .granularity(QueryRunnerTestHelper.allGran)
               .filters(filter)
               .dimensions(QueryRunnerTestHelper.qualityDimension)
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .query("a")
               .build(),
         expectedHits
@@ -473,7 +473,7 @@ public void testSearchWithMultiOrFilter()
               .granularity(QueryRunnerTestHelper.allGran)
               .dimensions(QueryRunnerTestHelper.qualityDimension)
               .filters(filter)
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .query("a")
               .build(),
         expectedHits
@@ -489,7 +489,7 @@ public void testSearchWithEmptyResults()
         Druids.newSearchQueryBuilder()
               .dataSource(QueryRunnerTestHelper.dataSource)
               .granularity(QueryRunnerTestHelper.allGran)
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .query("abcd123")
               .build(),
         expectedHits
@@ -511,7 +511,7 @@ public void testSearchWithFilterEmptyResults()
               .dataSource(QueryRunnerTestHelper.dataSource)
               .granularity(QueryRunnerTestHelper.allGran)
               .filters(filter)
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .query("a")
               .build(),
         expectedHits
@@ -528,7 +528,7 @@ public void testSearchNonExistingDimension()
         Druids.newSearchQueryBuilder()
               .dataSource(QueryRunnerTestHelper.dataSource)
               .granularity(QueryRunnerTestHelper.allGran)
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .dimensions("does_not_exist")
               .query("a")
               .build(),
@@ -548,7 +548,7 @@ public void testSearchAll()
         Druids.newSearchQueryBuilder()
               .dataSource(QueryRunnerTestHelper.dataSource)
               .granularity(QueryRunnerTestHelper.allGran)
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .dimensions(QueryRunnerTestHelper.marketDimension)
               .query("")
               .build(),
@@ -558,7 +558,7 @@ public void testSearchAll()
         Druids.newSearchQueryBuilder()
               .dataSource(QueryRunnerTestHelper.dataSource)
               .granularity(QueryRunnerTestHelper.allGran)
-              .intervals(QueryRunnerTestHelper.fullOnInterval)
+              .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
               .dimensions(QueryRunnerTestHelper.marketDimension)
               .build(),
         expectedHits
@@ -571,7 +571,7 @@ public void testSearchWithNumericSort()
     SearchQuery searchQuery = Druids.newSearchQueryBuilder()
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .query("a")
                                     .sortSpec(new SearchSortSpec(StringComparators.NUMERIC))
                                     .build();
@@ -595,7 +595,7 @@ public void testSearchOnTime()
     SearchQuery searchQuery = Druids.newSearchQueryBuilder()
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .query("Friday")
                                     .dimensions(new ExtractionDimensionSpec(
                                         Column.TIME_COLUMN_NAME,
@@ -628,7 +628,7 @@ public void testSearchOnLongColumn()
                                     )
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .query("1297123200000")
                                     .build();
 
@@ -652,7 +652,7 @@ public void testSearchOnLongColumnWithExFn()
                                     )
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .query("1297123200000")
                                     .build();
 
@@ -673,7 +673,7 @@ public void testSearchOnFloatColumn()
                                     )
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .query("100.7")
                                     .build();
 
@@ -698,7 +698,7 @@ public void testSearchOnFloatColumnWithExFn()
                                     )
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .query("100.7")
                                     .build();
 
@@ -741,7 +741,7 @@ public void testSearchWithNullValueInDimension() throws Exception
                                     )
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     // simulate when cardinality is big enough to fallback to cursorOnly strategy
                                     .context(ImmutableMap.of("searchStrategy", "cursorOnly"))
                                     .build();
@@ -769,7 +769,7 @@ public void testSearchWithNotExistedDimension()
                                     )
                                     .dataSource(QueryRunnerTestHelper.dataSource)
                                     .granularity(QueryRunnerTestHelper.allGran)
-                                    .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                    .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                     .build();
 
     List<SearchHit> noHit = new ArrayList<>();
diff --git a/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerWithCaseTest.java b/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerWithCaseTest.java
index cac1bcdc3d5f..875b0b82e674 100644
--- a/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerWithCaseTest.java
+++ b/processing/src/test/java/org/apache/druid/query/search/SearchQueryRunnerWithCaseTest.java
@@ -52,7 +52,7 @@
 import static org.apache.druid.query.QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator;
 import static org.apache.druid.query.QueryRunnerTestHelper.allGran;
 import static org.apache.druid.query.QueryRunnerTestHelper.dataSource;
-import static org.apache.druid.query.QueryRunnerTestHelper.fullOnInterval;
+import static org.apache.druid.query.QueryRunnerTestHelper.fullOnIntervalSpec;
 import static org.apache.druid.query.QueryRunnerTestHelper.makeQueryRunner;
 import static org.apache.druid.query.QueryRunnerTestHelper.marketDimension;
 import static org.apache.druid.query.QueryRunnerTestHelper.placementDimension;
@@ -148,7 +148,7 @@ private Druids.SearchQueryBuilder testBuilder()
     return Druids.newSearchQueryBuilder()
                  .dataSource(dataSource)
                  .granularity(allGran)
-                 .intervals(fullOnInterval);
+                 .intervals(fullOnIntervalSpec);
   }
 
   @Test
diff --git a/processing/src/test/java/org/apache/druid/query/search/SearchQueryTest.java b/processing/src/test/java/org/apache/druid/query/search/SearchQueryTest.java
index 7d84646ee877..7dda00f4f1ed 100644
--- a/processing/src/test/java/org/apache/druid/query/search/SearchQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/search/SearchQueryTest.java
@@ -41,7 +41,7 @@ public void testQuerySerialization() throws IOException
     Query query = Druids.newSearchQueryBuilder()
                         .dataSource(QueryRunnerTestHelper.dataSource)
                         .granularity(QueryRunnerTestHelper.allGran)
-                        .intervals(QueryRunnerTestHelper.fullOnInterval)
+                        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                         .query("a")
                         .build();
 
@@ -57,7 +57,7 @@ public void testEquals()
     Query query1 = Druids.newSearchQueryBuilder()
                          .dataSource(QueryRunnerTestHelper.dataSource)
                          .granularity(QueryRunnerTestHelper.allGran)
-                         .intervals(QueryRunnerTestHelper.fullOnInterval)
+                         .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                          .dimensions(
                              new DefaultDimensionSpec(
                                  QueryRunnerTestHelper.qualityDimension,
@@ -69,7 +69,7 @@ public void testEquals()
     Query query2 = Druids.newSearchQueryBuilder()
                          .dataSource(QueryRunnerTestHelper.dataSource)
                          .granularity(QueryRunnerTestHelper.allGran)
-                         .intervals(QueryRunnerTestHelper.fullOnInterval)
+                         .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                          .dimensions(
                              new DefaultDimensionSpec(
                                  QueryRunnerTestHelper.qualityDimension,
@@ -88,7 +88,7 @@ public void testSerDe() throws IOException
     Query query = Druids.newSearchQueryBuilder()
                         .dataSource(QueryRunnerTestHelper.dataSource)
                         .granularity(QueryRunnerTestHelper.allGran)
-                        .intervals(QueryRunnerTestHelper.fullOnInterval)
+                        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                         .dimensions(new LegacyDimensionSpec(QueryRunnerTestHelper.qualityDimension))
                         .query("a")
                         .build();
diff --git a/processing/src/test/java/org/apache/druid/query/select/DefaultSelectQueryMetricsTest.java b/processing/src/test/java/org/apache/druid/query/select/DefaultSelectQueryMetricsTest.java
index c97442bff433..71ffbee1ba1e 100644
--- a/processing/src/test/java/org/apache/druid/query/select/DefaultSelectQueryMetricsTest.java
+++ b/processing/src/test/java/org/apache/druid/query/select/DefaultSelectQueryMetricsTest.java
@@ -48,7 +48,7 @@ public void testDefaultSelectQueryMetricsQuery()
         .newSelectQueryBuilder()
         .dataSource(QueryRunnerTestHelper.dataSource)
         .granularity(QueryRunnerTestHelper.dayGran)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .descending(true)
         .pagingSpec(PagingSpec.newSpec(1))
         .build();
@@ -66,7 +66,7 @@ public void testDefaultSelectQueryMetricsQuery()
     Assert.assertEquals("", actualEvent.get("service"));
     Assert.assertEquals(QueryRunnerTestHelper.dataSource, actualEvent.get(DruidMetrics.DATASOURCE));
     Assert.assertEquals(query.getType(), actualEvent.get(DruidMetrics.TYPE));
-    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnInterval.getIntervals();
+    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnIntervalSpec.getIntervals();
     List<String> expectedStringIntervals =
         expectedIntervals.stream().map(Interval::toString).collect(Collectors.toList());
     Assert.assertEquals(expectedStringIntervals, actualEvent.get(DruidMetrics.INTERVAL));
@@ -88,7 +88,7 @@ public void testDefaultSelectQueryMetricsMetricNamesAndUnits()
         .newSelectQueryBuilder()
         .dataSource(QueryRunnerTestHelper.dataSource)
         .granularity(QueryRunnerTestHelper.dayGran)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .descending(true)
         .pagingSpec(PagingSpec.newSpec(1))
         .build();
diff --git a/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
index 0c0089e16837..4aee7440e7c9 100644
--- a/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
@@ -76,7 +76,7 @@
 /**
  */
 @RunWith(Parameterized.class)
-public class SelectQueryRunnerTest
+  public class SelectQueryRunnerTest
 {
   // copied from druid.sample.numeric.tsv
   public static final String[] V_0112 = {
@@ -110,13 +110,12 @@ public class SelectQueryRunnerTest
       "2011-01-13T00:00:00.000Z\tupfront\tpremium\t1600\t16000.0\t160000\tpreferred\tp
preferred\t1564.617729\tvalue"
   };
 
-  private static final String segmentIdString = QueryRunnerTestHelper.segmentId.toString();
-
-
   private static final Interval I_0112_0114 = Intervals.of("2011-01-12/2011-01-14");
   public static final QuerySegmentSpec I_0112_0114_SPEC = new LegacySegmentSpec(I_0112_0114);
   private static final SegmentId SEGMENT_ID_I_0112_0114 = QueryRunnerTestHelper.segmentId.withInterval(I_0112_0114);
 
+  private static final String segmentIdString = SEGMENT_ID_I_0112_0114.toString();
+
   public static final String[] V_0112_0114 = ObjectArrays.concat(V_0112, V_0113, String.class);
 
   private static final boolean DEFAULT_FROM_NEXT = true;
@@ -161,7 +160,7 @@ private Druids.SelectQueryBuilder newTestQuery()
                  .dataSource(new TableDataSource(QueryRunnerTestHelper.dataSource))
                  .dimensionSpecs(DefaultDimensionSpec.toSpec(Collections.emptyList()))
                  .metrics(Collections.emptyList())
-                 .intervals(QueryRunnerTestHelper.fullOnInterval)
+                 .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                  .granularity(QueryRunnerTestHelper.allGran)
                  .pagingSpec(PagingSpec.newSpec(3))
                  .descending(descending);
@@ -179,6 +178,7 @@ public void testFullOnSelect()
 
     PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
+        segmentIdString,
         toFullEvents(V_0112_0114),
         Lists.newArrayList(
             "market",
@@ -274,18 +274,20 @@ public void testFullOnSelectWithDimensionSpec()
     HashMap<String, Object> context = new HashMap<String, Object>();
     Iterable<Result<SelectResultValue>> results = runner.run(QueryPlus.wrap(query), context).toList();
 
+    String segmentIdInThisQuery = QueryRunnerTestHelper.segmentId.toString();
+
     List<Result<SelectResultValue>> expectedResultsAsc = Collections.singletonList(
         new Result<SelectResultValue>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new SelectResultValue(
-                ImmutableMap.of(segmentIdString, 2),
+                ImmutableMap.of(segmentIdInThisQuery, 2),
                 Sets.newHashSet("mar", "qual", "place"),
                 Sets.newHashSet("index", "quality_uniques", "indexMin", "indexMaxPlusTen", "indexMinFloat",
                     "indexFloat", "indexMaxFloat"
                 ),
                 Arrays.asList(
                     new EventHolder(
-                        segmentIdString,
+                        segmentIdInThisQuery,
                         0,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -296,7 +298,7 @@ public void testFullOnSelectWithDimensionSpec()
                             .build()
                     ),
                     new EventHolder(
-                        segmentIdString,
+                        segmentIdInThisQuery,
                         1,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -307,7 +309,7 @@ public void testFullOnSelectWithDimensionSpec()
                             .build()
                     ),
                     new EventHolder(
-                        segmentIdString,
+                        segmentIdInThisQuery,
                         2,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-01-12T00:00:00.000Z"))
@@ -326,14 +328,14 @@ public void testFullOnSelectWithDimensionSpec()
         new Result<SelectResultValue>(
             DateTimes.of("2011-01-12T00:00:00.000Z"),
             new SelectResultValue(
-                ImmutableMap.of(segmentIdString, -3),
+                ImmutableMap.of(segmentIdInThisQuery, -3),
                 Sets.newHashSet("mar", "qual", "place"),
                 Sets.newHashSet("index", "quality_uniques", "indexMin", "indexMaxPlusTen", "indexMinFloat",
                     "indexFloat", "indexMaxFloat"
                 ),
                 Arrays.asList(
                     new EventHolder(
-                        segmentIdString,
+                        segmentIdInThisQuery,
                         -1,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-04-15T00:00:00.000Z"))
@@ -344,7 +346,7 @@ public void testFullOnSelectWithDimensionSpec()
                             .build()
                     ),
                     new EventHolder(
-                        segmentIdString,
+                        segmentIdInThisQuery,
                         -2,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-04-15T00:00:00.000Z"))
@@ -355,7 +357,7 @@ public void testFullOnSelectWithDimensionSpec()
                             .build()
                     ),
                     new EventHolder(
-                        segmentIdString,
+                        segmentIdInThisQuery,
                         -3,
                         new ImmutableMap.Builder<String, Object>()
                             .put(EventHolder.timestampKey, DateTimes.of("2011-04-15T00:00:00.000Z"))
@@ -387,6 +389,7 @@ public void testSelectWithDimsAndMets()
 
     PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
+        segmentIdString,
         toEvents(
             new String[]{
                 EventHolder.timestampKey + ":TIME",
@@ -423,6 +426,7 @@ public void testSelectPagination()
 
     PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
+        segmentIdString,
         toEvents(
             new String[]{
                 EventHolder.timestampKey + ":TIME",
@@ -492,6 +496,7 @@ public void testFullOnSelectWithFilter()
 
       PagingOffset offset = query.getPagingOffset(segmentIdString);
       List<Result<SelectResultValue>> expectedResults = toExpected(
+          segmentIdString,
           events,
           Collections.singletonList("quality"),
           Collections.singletonList("index"),
@@ -505,8 +510,9 @@ public void testFullOnSelectWithFilter()
   @Test
   public void testFullOnSelectWithFilterOnVirtualColumn()
   {
+    Interval interval = Intervals.of("2011-01-13/2011-01-14");
     SelectQuery query = newTestQuery()
-        .intervals("2011-01-13/2011-01-14")
+        .intervals(new LegacySegmentSpec(interval))
         .filters(
             new AndDimFilter(
                 Arrays.asList(
@@ -524,7 +530,7 @@ public void testFullOnSelectWithFilterOnVirtualColumn()
         )
         .build();
 
-    HashMap<String, Object> context = new HashMap<String, Object>();
+    HashMap<String, Object> context = new HashMap<>();
     Iterable<Result<SelectResultValue>> results = runner.run(QueryPlus.wrap(query), context).toList();
 
     final List<List<Map<String, Object>>> events = toEvents(
@@ -543,8 +549,10 @@ public void testFullOnSelectWithFilterOnVirtualColumn()
         }
     );
 
-    PagingOffset offset = query.getPagingOffset(segmentIdString);
+    String segmentIdInThisQuery = QueryRunnerTestHelper.segmentId.withInterval(interval).toString();
+    PagingOffset offset = query.getPagingOffset(segmentIdInThisQuery);
     List<Result<SelectResultValue>> expectedResults = toExpected(
+        segmentIdInThisQuery,
         events,
         Collections.singletonList("quality"),
         Collections.singletonList("index"),
@@ -598,6 +606,7 @@ public void testSelectWithFilterLookupExtractionFn()
 
     PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
+        segmentIdString,
         events,
         Collections.singletonList(QueryRunnerTestHelper.qualityDimension),
         Collections.singletonList(QueryRunnerTestHelper.indexMetric),
@@ -682,6 +691,7 @@ public void testFullSelectNoDimensionAndMetric()
 
     PagingOffset offset = query.getPagingOffset(segmentIdString);
     List<Result<SelectResultValue>> expectedResults = toExpected(
+        segmentIdString,
         events,
         Collections.singletonList("foo"),
         Collections.singletonList("foo2"),
@@ -980,6 +990,7 @@ public Map<String, Object> apply(String input)
   }
 
   private List<Result<SelectResultValue>> toExpected(
+      String segmentId,
       List<List<Map<String, Object>>> targets,
       List<String> dimensions,
       List<String> metrics,
@@ -998,12 +1009,12 @@ private List<Result<SelectResultValue>> toExpected(
         int start = group.size() + offset;
         int end = Math.max(-1, start - threshold);
         for (int i = start; i > end; i--) {
-          holders.add(new EventHolder(segmentIdString, newOffset--, group.get(i)));
+          holders.add(new EventHolder(segmentId, newOffset--, group.get(i)));
         }
       } else {
         int end = Math.min(group.size(), offset + threshold);
         for (int i = offset; i < end; i++) {
-          holders.add(new EventHolder(segmentIdString, newOffset++, group.get(i)));
+          holders.add(new EventHolder(segmentId, newOffset++, group.get(i)));
         }
       }
       int lastOffset = holders.isEmpty() ? offset : holders.get(holders.size() - 1).getOffset();
@@ -1011,7 +1022,7 @@ private List<Result<SelectResultValue>> toExpected(
           new Result(
               new DateTime(group.get(0).get(EventHolder.timestampKey), ISOChronology.getInstanceUTC()),
               new SelectResultValue(
-                  ImmutableMap.of(segmentIdString, lastOffset),
+                  ImmutableMap.of(segmentId, lastOffset),
                   Sets.newHashSet(dimensions),
                   Sets.newHashSet(metrics),
                   holders)
diff --git a/processing/src/test/java/org/apache/druid/query/timeseries/DefaultTimeseriesQueryMetricsTest.java b/processing/src/test/java/org/apache/druid/query/timeseries/DefaultTimeseriesQueryMetricsTest.java
index 2727123a7164..e29599f3f789 100644
--- a/processing/src/test/java/org/apache/druid/query/timeseries/DefaultTimeseriesQueryMetricsTest.java
+++ b/processing/src/test/java/org/apache/druid/query/timeseries/DefaultTimeseriesQueryMetricsTest.java
@@ -51,7 +51,7 @@ public void testDefaultTimeseriesQueryMetricsQuery()
         .newTimeseriesQueryBuilder()
         .dataSource(QueryRunnerTestHelper.dataSource)
         .granularity(QueryRunnerTestHelper.dayGran)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(QueryRunnerTestHelper.rowsCount, QueryRunnerTestHelper.indexDoubleSum)
         .postAggregators(QueryRunnerTestHelper.addRowsIndexConstant)
         .descending(true)
@@ -67,7 +67,7 @@ public void testDefaultTimeseriesQueryMetricsQuery()
     Assert.assertEquals("", actualEvent.get("service"));
     Assert.assertEquals(QueryRunnerTestHelper.dataSource, actualEvent.get(DruidMetrics.DATASOURCE));
     Assert.assertEquals(query.getType(), actualEvent.get(DruidMetrics.TYPE));
-    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnInterval.getIntervals();
+    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnIntervalSpec.getIntervals();
     List<String> expectedStringIntervals =
         expectedIntervals.stream().map(Interval::toString).collect(Collectors.toList());
     Assert.assertEquals(expectedStringIntervals, actualEvent.get(DruidMetrics.INTERVAL));
diff --git a/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerTest.java
index 1a218b336839..cfa1be704c67 100644
--- a/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryRunnerTest.java
@@ -169,7 +169,7 @@ public void testFullOnTimeseries()
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(gran)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       QueryRunnerTestHelper.rowsCount,
                                       QueryRunnerTestHelper.indexDoubleSum,
@@ -275,7 +275,7 @@ public void testTimeseriesNoAggregators()
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(gran)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .descending(descending)
                                   .build();
 
@@ -305,7 +305,7 @@ public void testFullOnTimeseriesMaxMin()
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(Granularities.ALL)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       Arrays.asList(
                                           new DoubleMaxAggregatorFactory("maxIndex", "index"),
@@ -341,7 +341,7 @@ public void testFullOnTimeseriesWithFilter()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(QueryRunnerTestHelper.dayGran)
                                   .filters(QueryRunnerTestHelper.marketDimension, "upfront")
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       Arrays.asList(
                                           QueryRunnerTestHelper.rowsCount,
@@ -1803,7 +1803,7 @@ public void testTimeseriesWithFirstLastAggregator()
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(QueryRunnerTestHelper.monthGran)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       ImmutableList.of(
                                           new DoubleFirstAggregatorFactory("first", "index"),
@@ -2442,7 +2442,7 @@ public void testTimeseriesWithLimit()
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.dataSource)
                                   .granularity(QueryRunnerTestHelper.dayGran)
-                                  .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                  .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                   .aggregators(
                                       Arrays.asList(
                                           QueryRunnerTestHelper.rowsCount,
diff --git a/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryTest.java b/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryTest.java
index 7463ca85951f..1240dfc86e92 100644
--- a/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/timeseries/TimeseriesQueryTest.java
@@ -56,7 +56,7 @@ public void testQuerySerialization() throws IOException
     Query query = Druids.newTimeseriesQueryBuilder()
         .dataSource(QueryRunnerTestHelper.dataSource)
         .granularity(QueryRunnerTestHelper.dayGran)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(QueryRunnerTestHelper.rowsCount, QueryRunnerTestHelper.indexDoubleSum)
         .postAggregators(QueryRunnerTestHelper.addRowsIndexConstant)
         .descending(descending)
diff --git a/processing/src/test/java/org/apache/druid/query/topn/DefaultTopNQueryMetricsTest.java b/processing/src/test/java/org/apache/druid/query/topn/DefaultTopNQueryMetricsTest.java
index 23abdb63df57..8de348bd4cda 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/DefaultTopNQueryMetricsTest.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/DefaultTopNQueryMetricsTest.java
@@ -62,7 +62,7 @@ public void testDefaultTopNQueryMetricsQuery()
             null
         ))
         .metric("count")
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(Collections.singletonList(new CountAggregatorFactory("count")))
         .threshold(5)
         .filters(new SelectorDimFilter("tags", "t3", null))
@@ -78,7 +78,7 @@ public void testDefaultTopNQueryMetricsQuery()
     Assert.assertEquals("", actualEvent.get("service"));
     Assert.assertEquals("xx", actualEvent.get(DruidMetrics.DATASOURCE));
     Assert.assertEquals(query.getType(), actualEvent.get(DruidMetrics.TYPE));
-    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnInterval.getIntervals();
+    List<Interval> expectedIntervals = QueryRunnerTestHelper.fullOnIntervalSpec.getIntervals();
     List<String> expectedStringIntervals =
         expectedIntervals.stream().map(Interval::toString).collect(Collectors.toList());
     Assert.assertEquals(expectedStringIntervals, actualEvent.get(DruidMetrics.INTERVAL));
diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryQueryToolChestTest.java b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryQueryToolChestTest.java
index 3463ba8d356c..5e03f843ce51 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryQueryToolChestTest.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryQueryToolChestTest.java
@@ -158,7 +158,7 @@ public void testMinTopNThreshold()
           .granularity(QueryRunnerTestHelper.allGran)
           .dimension(QueryRunnerTestHelper.placementishDimension)
           .metric(QueryRunnerTestHelper.indexMetric)
-          .intervals(QueryRunnerTestHelper.fullOnInterval)
+          .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
           .aggregators(QueryRunnerTestHelper.commonDoubleAggregators);
 
       TopNQuery query1 = builder.threshold(10).context(null).build();
diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java
index c35abc8756d0..093b4061fb94 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java
@@ -67,7 +67,7 @@ public enum TestCases
       .dimension(marketDimension)
       .metric(QueryRunnerTestHelper.indexMetric)
       .threshold(4)
-      .intervals(QueryRunnerTestHelper.fullOnInterval)
+      .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
       .aggregators(
           Lists.newArrayList(
               Iterables.concat(
diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerTest.java
index 27427e7f5530..72a7a47aa401 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerTest.java
@@ -315,7 +315,7 @@ public void testFullOnTopN()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.indexMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -387,7 +387,7 @@ public void testTopNOnMissingColumn()
         .dimension(new DefaultDimensionSpec("nonexistentColumn", "alias"))
         .metric("rows")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(Collections.singletonList(new CountAggregatorFactory("rows")))
         .build();
 
@@ -413,7 +413,7 @@ public void testTopNOnMissingColumnWithExtractionFn()
         .dimension(new ExtractionDimensionSpec("nonexistentColumn", "alias", new StringFormatExtractionFn("theValue")))
         .metric("rows")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(Collections.singletonList(new CountAggregatorFactory("rows")))
         .build();
 
@@ -442,7 +442,7 @@ public void testFullOnTopNOverPostAggs()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.addRowsIndexConstantMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -505,7 +505,7 @@ public void testFullOnTopNOverPostAggsOnDimension()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric("dimPostAgg")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -577,7 +577,7 @@ public void testFullOnTopNOverUniques()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.uniqueMetric)
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -640,7 +640,7 @@ public void testTopNOverMissingUniques()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.uniqueMetric)
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Collections.<AggregatorFactory>singletonList(new HyperUniquesAggregatorFactory("uniques", "missingUniques"))
         )
@@ -679,7 +679,7 @@ public void testTopNOverHyperUniqueFinalizingPostAggregator()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.hyperUniqueFinalizingPostAggMetric)
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Collections.<AggregatorFactory>singletonList(QueryRunnerTestHelper.qualityUniques)
         )
@@ -727,7 +727,7 @@ public void testTopNOverHyperUniqueExpression()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.hyperUniqueFinalizingPostAggMetric)
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Collections.<AggregatorFactory>singletonList(QueryRunnerTestHelper.qualityUniques)
         )
@@ -783,7 +783,7 @@ public void testTopNOverHyperUniqueExpressionRounded()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.hyperUniqueFinalizingPostAggMetric)
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Collections.<AggregatorFactory>singletonList(QueryRunnerTestHelper.qualityUniquesRounded)
         )
@@ -833,7 +833,7 @@ public void testTopNOverFirstLastAggregator()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric("last")
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Arrays.asList(
                 new LongFirstAggregatorFactory("first", "index"),
@@ -944,7 +944,7 @@ public void testTopNOverFirstLastAggregatorChunkPeriod()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric("last")
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Arrays.asList(
                 new LongFirstAggregatorFactory("first", "index"),
@@ -1058,7 +1058,7 @@ public void testTopNOverFirstLastFloatAggregatorUsingDoubleColumn()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric("last")
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Arrays.asList(
                 new FloatFirstAggregatorFactory("first", "index"),
@@ -1169,7 +1169,7 @@ public void testTopNOverFirstLastFloatAggregatorUsingFloatColumn()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric("last")
         .threshold(3)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Arrays.asList(
                 new FloatFirstAggregatorFactory("first", "indexFloat"),
@@ -2340,7 +2340,7 @@ public void testTopNDimExtractionToOne()
         )
         .metric("rows")
         .threshold(10)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(commonAggregators)
         .postAggregators(Collections.singletonList(QueryRunnerTestHelper.addRowsIndexConstant))
         .build();
@@ -2381,7 +2381,7 @@ public void testTopNCollapsingDimExtraction()
         )
         .metric("index")
         .threshold(2)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Arrays.asList(
                 QueryRunnerTestHelper.rowsCount,
@@ -3626,7 +3626,7 @@ public void testTopNDependentPostAgg()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.dependentPostAggMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -3710,7 +3710,7 @@ public void testTopNBySegmentResults()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.dependentPostAggMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -3855,7 +3855,7 @@ public void testTopNTimeExtraction()
         )
         .metric("index")
         .threshold(2)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Arrays.asList(
                 QueryRunnerTestHelper.rowsCount,
@@ -3898,7 +3898,7 @@ public void testTopNOverNullDimension()
         .dimension("null_column")
         .metric(QueryRunnerTestHelper.indexMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -3946,7 +3946,7 @@ public void testTopNOverNullDimensionWithFilter()
         )
         .metric(QueryRunnerTestHelper.indexMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4232,7 +4232,7 @@ public void testTopNWithExtractionFilterAndFilteredAggregatorCaseNoExistingValue
         .dimension("null_column")
         .metric(QueryRunnerTestHelper.indexMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4311,7 +4311,7 @@ public void testTopNWithExtractionFilterNoExistingValue()
         .dimension("null_column")
         .metric(QueryRunnerTestHelper.indexMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(Lists.newArrayList(Iterables.concat(commonAggregators, Lists.newArrayList(
             new FilteredAggregatorFactory(new DoubleMaxAggregatorFactory("maxIndex", "index"),
                                           extractionFilter),
@@ -4355,7 +4355,7 @@ public void testFullOnTopNFloatColumn()
         .dimension(new DefaultDimensionSpec(QueryRunnerTestHelper.indexMetric, "index_alias", ValueType.FLOAT))
         .metric(QueryRunnerTestHelper.indexMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4430,7 +4430,7 @@ public void testFullOnTopNFloatColumnWithExFn()
         .dimension(new ExtractionDimensionSpec(QueryRunnerTestHelper.indexMetric, "index_alias", jsExtractionFn))
         .metric(QueryRunnerTestHelper.indexMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4502,7 +4502,7 @@ public void testFullOnTopNFloatColumnAsString()
         .dimension(new DefaultDimensionSpec("qualityFloat", "qf_alias"))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4574,7 +4574,7 @@ public void testFullOnTopNLongColumn()
         .dimension(new DefaultDimensionSpec("qualityLong", "ql_alias", ValueType.LONG))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4646,7 +4646,7 @@ public void testFullOnTopNLongVirtualColumn()
         .dimension(new DefaultDimensionSpec("ql_expr", "ql_alias", ValueType.LONG))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4777,7 +4777,7 @@ public void testFullOnTopNLongColumnWithExFn()
         .dimension(new ExtractionDimensionSpec("qualityLong", "ql_alias", jsExtractionFn))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4849,7 +4849,7 @@ public void testFullOnTopNLongColumnAsString()
         .dimension(new DefaultDimensionSpec("qualityLong", "ql_alias"))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4921,7 +4921,7 @@ public void testFullOnTopNNumericStringColumnAsLong()
         .dimension(new DefaultDimensionSpec("qualityNumericString", "qns_alias", ValueType.LONG))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -4993,7 +4993,7 @@ public void testFullOnTopNNumericStringColumnAsFloat()
         .dimension(new DefaultDimensionSpec("qualityNumericString", "qns_alias", ValueType.FLOAT))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -5065,7 +5065,7 @@ public void testFullOnTopNLongTimeColumn()
         .dimension(new DefaultDimensionSpec(Column.TIME_COLUMN_NAME, "time_alias", ValueType.LONG))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -5137,7 +5137,7 @@ public void testSortOnDoubleAsLong()
         .dimension(new DefaultDimensionSpec("index", "index_alias", ValueType.LONG))
         .metric(new DimensionTopNMetricSpec(null, StringComparators.NUMERIC))
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .build();
 
     List<Result<TopNResultValue>> expectedResults = Collections.singletonList(
@@ -5173,7 +5173,7 @@ public void testSortOnTimeAsLong()
         .dimension(new DefaultDimensionSpec("__time", "__time_alias", ValueType.LONG))
         .metric(new DimensionTopNMetricSpec(null, StringComparators.NUMERIC))
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .build();
 
     List<Result<TopNResultValue>> expectedResults = Collections.singletonList(
@@ -5209,7 +5209,7 @@ public void testSortOnStringAsDouble()
         .dimension(new DefaultDimensionSpec("market", "alias", ValueType.DOUBLE))
         .metric(new DimensionTopNMetricSpec(null, StringComparators.NUMERIC))
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .build();
 
     final Map<String, Object> nullAliasMap = new HashMap<>();
@@ -5233,7 +5233,7 @@ public void testSortOnDoubleAsDouble()
         .dimension(new DefaultDimensionSpec("index", "index_alias", ValueType.DOUBLE))
         .metric(new DimensionTopNMetricSpec(null, StringComparators.NUMERIC))
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .build();
 
     List<Result<TopNResultValue>> expectedResults = Collections.singletonList(
@@ -5272,7 +5272,7 @@ public void testFullOnTopNLongTimeColumnWithExFn()
         .dimension(new ExtractionDimensionSpec(Column.TIME_COLUMN_NAME, "time_alias", jsExtractionFn))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -5351,7 +5351,7 @@ public void testFullOnTopNDimExtractionAllNulls()
         ))
         .metric(QueryRunnerTestHelper.indexMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -5399,7 +5399,7 @@ public void testFullOnTopNStringOutputAsLong()
         .dimension(new ExtractionDimensionSpec(QueryRunnerTestHelper.qualityDimension, "alias", ValueType.LONG, strlenFn))
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -5477,7 +5477,7 @@ public void testFullOnTopNNumericStringColumnWithDecoration()
         .dimension(filteredSpec)
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -5546,7 +5546,7 @@ public void testFullOnTopNDecorationOnNumeric()
         .dimension(filteredSpec)
         .metric("maxIndex")
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -5656,7 +5656,7 @@ public void testFullOnTopNWithAggsOnNumericDims()
           .granularity(QueryRunnerTestHelper.allGran)
           .dimension(QueryRunnerTestHelper.marketDimension)
           .threshold(4)
-          .intervals(QueryRunnerTestHelper.fullOnInterval)
+          .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
           .aggregators(aggregationCombination.stream().map(agg -> agg.lhs).collect(Collectors.toList()));
       String metric;
       if (hasIndexAggregator) {
@@ -5719,7 +5719,7 @@ public void testFullOnTopNBoundFilterAndLongSumMetric()
         ))
         .metric("Count")
         .threshold(5)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Collections.singletonList(new LongSumAggregatorFactory("Count", "qualityLong"))
         )
diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryTest.java b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryTest.java
index 44a030c9e5f6..c86f3cb5b54c 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/TopNQueryTest.java
@@ -42,7 +42,7 @@
 import static org.apache.druid.query.QueryRunnerTestHelper.allGran;
 import static org.apache.druid.query.QueryRunnerTestHelper.commonDoubleAggregators;
 import static org.apache.druid.query.QueryRunnerTestHelper.dataSource;
-import static org.apache.druid.query.QueryRunnerTestHelper.fullOnInterval;
+import static org.apache.druid.query.QueryRunnerTestHelper.fullOnIntervalSpec;
 import static org.apache.druid.query.QueryRunnerTestHelper.indexMetric;
 import static org.apache.druid.query.QueryRunnerTestHelper.marketDimension;
 import static org.apache.druid.query.QueryRunnerTestHelper.rowsCount;
@@ -60,7 +60,7 @@ public void testQuerySerialization() throws IOException
         .dimension(marketDimension)
         .metric(indexMetric)
         .threshold(4)
-        .intervals(fullOnInterval)
+        .intervals(fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -97,7 +97,7 @@ public void testQuerySerdeWithLookupExtractionFn() throws IOException
         )
         .metric(new NumericTopNMetricSpec(indexMetric))
         .threshold(2)
-        .intervals(fullOnInterval.getIntervals())
+        .intervals(fullOnIntervalSpec.getIntervals())
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(
@@ -123,7 +123,7 @@ public void testQuerySerdeWithAlphaNumericTopNMetricSpec() throws IOException
         .dimension(new LegacyDimensionSpec(marketDimension))
         .metric(new DimensionTopNMetricSpec(null, StringComparators.ALPHANUMERIC))
         .threshold(2)
-        .intervals(fullOnInterval.getIntervals())
+        .intervals(fullOnIntervalSpec.getIntervals())
         .aggregators(Collections.singletonList(rowsCount))
         .build();
     String jsonQuery = "{\n"
diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNUnionQueryTest.java b/processing/src/test/java/org/apache/druid/query/topn/TopNUnionQueryTest.java
index 4913fbbff90f..0aa1fcde8827 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNUnionQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/topn/TopNUnionQueryTest.java
@@ -110,7 +110,7 @@ public void testTopNUnionQuery()
         .dimension(QueryRunnerTestHelper.marketDimension)
         .metric(QueryRunnerTestHelper.dependentPostAggMetric)
         .threshold(4)
-        .intervals(QueryRunnerTestHelper.fullOnInterval)
+        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
         .aggregators(
             Lists.newArrayList(
                 Iterables.concat(

From 1d82f8cb21a6d872b5469f2f2ca97eea0fd094e1 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Fri, 28 Sep 2018 16:54:20 -0300
Subject: [PATCH 04/27] Fix indentation

---
 .../org/apache/druid/query/select/SelectQueryRunnerTest.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
index 4aee7440e7c9..2cda7d653a95 100644
--- a/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/select/SelectQueryRunnerTest.java
@@ -76,7 +76,7 @@
 /**
  */
 @RunWith(Parameterized.class)
-  public class SelectQueryRunnerTest
+public class SelectQueryRunnerTest
 {
   // copied from druid.sample.numeric.tsv
   public static final String[] V_0112 = {

From 17a365177abfb0b5f4cdeecd1eac47f4945aed7c Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Sun, 30 Sep 2018 09:50:05 -0300
Subject: [PATCH 05/27] Fixes

---
 .../java/org/apache/druid/timeline/SegmentId.java     |  6 +++---
 .../java/org/apache/druid/client/DruidDataSource.java | 11 +++--------
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/api/src/main/java/org/apache/druid/timeline/SegmentId.java b/api/src/main/java/org/apache/druid/timeline/SegmentId.java
index 566f813cf645..f07a95227605 100644
--- a/api/src/main/java/org/apache/druid/timeline/SegmentId.java
+++ b/api/src/main/java/org/apache/druid/timeline/SegmentId.java
@@ -61,8 +61,8 @@ public final class SegmentId implements Comparable<SegmentId>
    */
 
   /**
-   * {@link #dataSource} and {@link #version} are stored as canonical string values to decrease memory required for
-   * storing large numbers of segment identifiers.
+   * {@link #dataSource} field values are stored as canonical strings to decrease memory required for large numbers of
+   * segment identifiers.
    */
   private static final Interner<String> STRING_INTERNER = Interners.newWeakInterner();
 
@@ -114,7 +114,7 @@ public static SegmentId tryParse(String dataSource, String segmentId)
    * Returns a (potentially empty) lazy iteration of all possible valid parsings of the given segment id string into
    * {@code SegmentId} objects.
    *
-   * Warning: this iterable is repeats most of the parsing work on each iteration, so it should be iterated only once if
+   * Warning: this iterable repeats most of the parsing work on each iteration, so it should be iterated only once if
    * possible.
    */
   public static Iterable<SegmentId> iterateAllPossibleParsings(String segmentId)
diff --git a/server/src/main/java/org/apache/druid/client/DruidDataSource.java b/server/src/main/java/org/apache/druid/client/DruidDataSource.java
index b366316239fa..7678dad68377 100644
--- a/server/src/main/java/org/apache/druid/client/DruidDataSource.java
+++ b/server/src/main/java/org/apache/druid/client/DruidDataSource.java
@@ -34,8 +34,8 @@
 /**
  * A mutable collection of metadata of segments ({@link DataSegment} objects), belonging to a particular data source.
  *
- * Concurrency: could be updated concurrently via {@link #addSegment} and {@link
- * #removeSegment}, and accessed concurrently (e. g. via {@link #getSegments} as well.
+ * Concurrency: could be updated concurrently via {@link #addSegment} and {@link #removeSegment}, and accessed
+ * concurrently (e. g. via {@link #getSegments}) as well.
  *
  * @see ImmutableDruidDataSource - an immutable counterpart of this class
  */
@@ -69,6 +69,7 @@ public Map<String, String> getProperties()
     return properties;
   }
 
+  @Nullable
   public DataSegment getSegment(SegmentId segmentId)
   {
     return idToSegmentMap.get(segmentId);
@@ -79,12 +80,6 @@ public Collection<DataSegment> getSegments()
     return Collections.unmodifiableCollection(idToSegmentMap.values());
   }
 
-  @Nullable
-  public DataSegment getSegment(String segmentId)
-  {
-    return idToSegmentMap.get(segmentId);
-  }
-
   public DruidDataSource addSegment(DataSegment dataSegment)
   {
     idToSegmentMap.put(dataSegment.getId(), dataSegment);

From e0c8ada59989ff404993ded8252651249f4b961b Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Sun, 30 Sep 2018 10:04:39 -0300
Subject: [PATCH 06/27] Remove Comparators.inverse() tests

---
 .../util/common/guava/ComparatorsTest.java    | 28 -------------------
 1 file changed, 28 deletions(-)

diff --git a/java-util/src/test/java/org/apache/druid/java/util/common/guava/ComparatorsTest.java b/java-util/src/test/java/org/apache/druid/java/util/common/guava/ComparatorsTest.java
index 0cc4dda49ba9..816e2d5a32a9 100644
--- a/java-util/src/test/java/org/apache/druid/java/util/common/guava/ComparatorsTest.java
+++ b/java-util/src/test/java/org/apache/druid/java/util/common/guava/ComparatorsTest.java
@@ -31,34 +31,6 @@
  */
 public class ComparatorsTest
 {
-  @Test
-  public void testInverse()
-  {
-    Comparator<Integer> normal = Comparator.naturalOrder();
-    Comparator<Integer> inverted = normal.reversed();
-
-    Assert.assertEquals(-1, normal.compare(0, 1));
-    Assert.assertEquals(1, normal.compare(1, 0));
-    Assert.assertEquals(0, normal.compare(1, 1));
-    Assert.assertEquals(1, inverted.compare(0, 1));
-    Assert.assertEquals(-1, inverted.compare(1, 0));
-    Assert.assertEquals(0, inverted.compare(1, 1));
-  }
-
-  @Test
-  public void testInverseOverflow()
-  {
-    Comparator<Integer> invertedSimpleIntegerComparator = new Comparator<Integer>()
-    {
-      @Override
-      public int compare(Integer o1, Integer o2)
-      {
-        return o1 - o2;
-      }
-    }.reversed();
-    Assert.assertTrue(invertedSimpleIntegerComparator.compare(0, Integer.MIN_VALUE) < 0);
-  }
-
   @Test
   public void testIntervalsByStartThenEnd()
   {

From 958622673ff56118e30618649e3ae6813eb67f3b Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Sun, 30 Sep 2018 10:16:21 -0300
Subject: [PATCH 07/27] Refinements

---
 .../query/topn/InvertedTopNMetricSpec.java      | 17 +----------------
 .../druid/client/HttpServerInventoryView.java   |  3 +++
 2 files changed, 4 insertions(+), 16 deletions(-)

diff --git a/processing/src/main/java/org/apache/druid/query/topn/InvertedTopNMetricSpec.java b/processing/src/main/java/org/apache/druid/query/topn/InvertedTopNMetricSpec.java
index d168f9b1f174..eac69d328375 100644
--- a/processing/src/main/java/org/apache/druid/query/topn/InvertedTopNMetricSpec.java
+++ b/processing/src/main/java/org/apache/druid/query/topn/InvertedTopNMetricSpec.java
@@ -66,22 +66,7 @@ public Comparator getComparator(
       final List<PostAggregator> postAggregatorSpecs
   )
   {
-    // nulls last
-    return ((Comparator<Object>) new Comparator()
-    {
-      @Override
-      public int compare(Object o1, Object o2)
-      {
-        // nulls last
-        if (o1 == null) {
-          return 1;
-        }
-        if (o2 == null) {
-          return -1;
-        }
-        return delegate.getComparator(aggregatorSpecs, postAggregatorSpecs).compare(o1, o2);
-      }
-    }).reversed();
+    return Comparator.nullsFirst(delegate.getComparator(aggregatorSpecs, postAggregatorSpecs).reversed());
   }
 
   @Override
diff --git a/server/src/main/java/org/apache/druid/client/HttpServerInventoryView.java b/server/src/main/java/org/apache/druid/client/HttpServerInventoryView.java
index e890328e1f93..0a3bcb99272c 100644
--- a/server/src/main/java/org/apache/druid/client/HttpServerInventoryView.java
+++ b/server/src/main/java/org/apache/druid/client/HttpServerInventoryView.java
@@ -277,6 +277,9 @@ public DruidServer getInventoryValue(String containerKey)
   @Override
   public Collection<DruidServer> getInventory()
   {
+    // Returning a lazy collection, because currently getInventory() is always used for one-time iteration. It's OK for
+    // storing in a field and repetitive iteration as well, because the lambda is very cheap - just a final field
+    // access.
     return Collections2.transform(servers.values(), serverHolder -> serverHolder.druidServer);
   }
 

From 47e9007a36d8d9c023f783a7330232ab0b1e97f6 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Mon, 1 Oct 2018 11:49:20 -0300
Subject: [PATCH 08/27] Fix tests

---
 .../apache/druid/query/DoubleStorageTest.java |  4 +--
 .../query/groupby/GroupByQueryRunnerTest.java | 32 ++++++++++++-------
 .../metadata/SegmentMetadataQueryTest.java    | 16 +++++-----
 3 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java b/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
index 00791e8944e5..f7c0d7f21bad 100644
--- a/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
+++ b/processing/src/test/java/org/apache/druid/query/DoubleStorageTest.java
@@ -149,7 +149,7 @@ public DoubleStorageTest(
   public static Collection<?> dataFeeder()
   {
     SegmentAnalysis expectedSegmentAnalysisDouble = new SegmentAnalysis(
-        "segmentId",
+        SEGMENT_ID.toString(),
         ImmutableList.of(INTERVAL),
         ImmutableMap.of(
             TIME_COLUMN,
@@ -191,7 +191,7 @@ public static Collection<?> dataFeeder()
     );
 
     SegmentAnalysis expectedSegmentAnalysisFloat = new SegmentAnalysis(
-        "segmentId",
+        SEGMENT_ID.toString(),
         ImmutableList.of(INTERVAL),
         ImmutableMap.of(
             TIME_COLUMN,
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
index 814f4d2475f0..8cf1c14cd222 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
@@ -6270,9 +6270,9 @@ public ExtractionType getExtractionType()
   public void testBySegmentResults()
   {
     int segmentCount = 32;
-    Result<BySegmentResultValue> singleSegmentResult = new Result<BySegmentResultValue>(
+    Result<BySegmentResultValue> singleSegmentResult = new Result<>(
         DateTimes.of("2011-01-12T00:00:00.000Z"),
-        new BySegmentResultValueClass(
+        new BySegmentResultValueClass<>(
             Collections.singletonList(
                 GroupByQueryRunnerTestHelper.createExpectedRow(
                     "2011-04-01",
@@ -6283,7 +6283,9 @@ public void testBySegmentResults()
                     "idx",
                     4420L
                 )
-            ), "testSegment", Intervals.of("2011-04-02T00:00:00.000Z/2011-04-04T00:00:00.000Z")
+            ),
+            QueryRunnerTestHelper.segmentId.toString(),
+            Intervals.of("2011-04-02T00:00:00.000Z/2011-04-04T00:00:00.000Z")
         )
     );
     List<Result> bySegmentResults = Lists.newArrayList();
@@ -6327,9 +6329,9 @@ public void testBySegmentResults()
   public void testBySegmentResultsUnOptimizedDimextraction()
   {
     int segmentCount = 32;
-    Result<BySegmentResultValue> singleSegmentResult = new Result<BySegmentResultValue>(
+    Result<BySegmentResultValue> singleSegmentResult = new Result<>(
         DateTimes.of("2011-01-12T00:00:00.000Z"),
-        new BySegmentResultValueClass(
+        new BySegmentResultValueClass<>(
             Collections.singletonList(
                 GroupByQueryRunnerTestHelper.createExpectedRow(
                     "2011-04-01",
@@ -6340,7 +6342,9 @@ public void testBySegmentResultsUnOptimizedDimextraction()
                     "idx",
                     4420L
                 )
-            ), "testSegment", Intervals.of("2011-04-02T00:00:00.000Z/2011-04-04T00:00:00.000Z")
+            ),
+            QueryRunnerTestHelper.segmentId.toString(),
+            Intervals.of("2011-04-02T00:00:00.000Z/2011-04-04T00:00:00.000Z")
         )
     );
     List<Result> bySegmentResults = Lists.newArrayList();
@@ -6387,9 +6391,9 @@ public void testBySegmentResultsUnOptimizedDimextraction()
   public void testBySegmentResultsOptimizedDimextraction()
   {
     int segmentCount = 32;
-    Result<BySegmentResultValue> singleSegmentResult = new Result<BySegmentResultValue>(
+    Result<BySegmentResultValue> singleSegmentResult = new Result<>(
         DateTimes.of("2011-01-12T00:00:00.000Z"),
-        new BySegmentResultValueClass(
+        new BySegmentResultValueClass<>(
             Collections.singletonList(
                 GroupByQueryRunnerTestHelper.createExpectedRow(
                     "2011-04-01",
@@ -6400,7 +6404,9 @@ public void testBySegmentResultsOptimizedDimextraction()
                     "idx",
                     4420L
                 )
-            ), "testSegment", Intervals.of("2011-04-02T00:00:00.000Z/2011-04-04T00:00:00.000Z")
+            ),
+            QueryRunnerTestHelper.segmentId.toString(),
+            Intervals.of("2011-04-02T00:00:00.000Z/2011-04-04T00:00:00.000Z")
         )
     );
     List<Result> bySegmentResults = Lists.newArrayList();
@@ -6868,9 +6874,9 @@ public void testGroupByWithExtractionDimFilterNullDims()
   public void testBySegmentResultsWithAllFiltersWithExtractionFns()
   {
     int segmentCount = 32;
-    Result<BySegmentResultValue> singleSegmentResult = new Result<BySegmentResultValue>(
+    Result<BySegmentResultValue> singleSegmentResult = new Result<>(
         DateTimes.of("2011-01-12T00:00:00.000Z"),
-        new BySegmentResultValueClass(
+        new BySegmentResultValueClass<>(
             Collections.singletonList(
                 GroupByQueryRunnerTestHelper.createExpectedRow(
                     "2011-04-01",
@@ -6881,7 +6887,9 @@ public void testBySegmentResultsWithAllFiltersWithExtractionFns()
                     "idx",
                     4420L
                 )
-            ), "testSegment", Intervals.of("2011-04-02T00:00:00.000Z/2011-04-04T00:00:00.000Z")
+            ),
+            QueryRunnerTestHelper.segmentId.toString(),
+            Intervals.of("2011-04-02T00:00:00.000Z/2011-04-04T00:00:00.000Z")
         )
     );
     List<Result> bySegmentResults = Lists.newArrayList();
diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java
index 97e6d808acef..b3c8750bd066 100644
--- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryTest.java
@@ -267,7 +267,7 @@ public void testSegmentMetadataQuery()
   public void testSegmentMetadataQueryWithRollupMerge()
   {
     SegmentAnalysis mergedSegmentAnalysis = new SegmentAnalysis(
-        differentIds ? "merged" : "testSegment",
+        differentIds ? "merged" : SegmentId.dummy("testSegment").toString(),
         null,
         ImmutableMap.of(
             "placement",
@@ -335,7 +335,7 @@ public void testSegmentMetadataQueryWithRollupMerge()
   public void testSegmentMetadataQueryWithHasMultipleValuesMerge()
   {
     SegmentAnalysis mergedSegmentAnalysis = new SegmentAnalysis(
-        differentIds ? "merged" : "testSegment",
+        differentIds ? "merged" : SegmentId.dummy("testSegment").toString(),
         null,
         ImmutableMap.of(
             "placement",
@@ -403,7 +403,7 @@ public void testSegmentMetadataQueryWithHasMultipleValuesMerge()
   public void testSegmentMetadataQueryWithComplexColumnMerge()
   {
     SegmentAnalysis mergedSegmentAnalysis = new SegmentAnalysis(
-        differentIds ? "merged" : "testSegment",
+        differentIds ? "merged" : SegmentId.dummy("testSegment").toString(),
         null,
         ImmutableMap.of(
             "placement",
@@ -518,7 +518,7 @@ private void testSegmentMetadataQueryWithDefaultAnalysisMerge(
   )
   {
     SegmentAnalysis mergedSegmentAnalysis = new SegmentAnalysis(
-        differentIds ? "merged" : "testSegment",
+        differentIds ? "merged" : SegmentId.dummy("testSegment").toString(),
         ImmutableList.of(expectedSegmentAnalysis1.getIntervals().get(0)),
         ImmutableMap.of(
             "__time",
@@ -582,7 +582,7 @@ private void testSegmentMetadataQueryWithDefaultAnalysisMerge(
   public void testSegmentMetadataQueryWithNoAnalysisTypesMerge()
   {
     SegmentAnalysis mergedSegmentAnalysis = new SegmentAnalysis(
-        differentIds ? "merged" : "testSegment",
+        differentIds ? "merged" : SegmentId.dummy("testSegment").toString(),
         null,
         ImmutableMap.of(
             "placement",
@@ -644,7 +644,7 @@ public void testSegmentMetadataQueryWithAggregatorsMerge()
       expectedAggregators.put(agg.getName(), agg.getCombiningFactory());
     }
     SegmentAnalysis mergedSegmentAnalysis = new SegmentAnalysis(
-        differentIds ? "merged" : "testSegment",
+        differentIds ? "merged" : SegmentId.dummy("testSegment").toString(),
         null,
         ImmutableMap.of(
             "placement",
@@ -702,7 +702,7 @@ public void testSegmentMetadataQueryWithAggregatorsMerge()
   public void testSegmentMetadataQueryWithTimestampSpecMerge()
   {
     SegmentAnalysis mergedSegmentAnalysis = new SegmentAnalysis(
-        differentIds ? "merged" : "testSegment",
+        differentIds ? "merged" : SegmentId.dummy("testSegment").toString(),
         null,
         ImmutableMap.of(
             "placement",
@@ -760,7 +760,7 @@ public void testSegmentMetadataQueryWithTimestampSpecMerge()
   public void testSegmentMetadataQueryWithQueryGranularityMerge()
   {
     SegmentAnalysis mergedSegmentAnalysis = new SegmentAnalysis(
-        differentIds ? "merged" : "testSegment",
+        differentIds ? "merged" : SegmentId.dummy("testSegment").toString(),
         null,
         ImmutableMap.of(
             "placement",

From 6da4f3a816c0c8264a5e3b9c9f715849c1641362 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Mon, 1 Oct 2018 14:50:37 -0300
Subject: [PATCH 09/27] Fix more tests

---
 .../java/org/apache/druid/timeline/DataSegmentTest.java    | 6 +++---
 .../org/apache/druid/indexer/HadoopTuningConfigTest.java   | 3 +--
 .../druid/query/metadata/metadata/SegmentAnalysis.java     | 4 ----
 .../java/org/apache/druid/guice/ExtensionsConfigTest.java  | 7 +------
 .../apache/druid/query/metadata/SegmentAnalyzerTest.java   | 4 ++--
 .../apache/druid/client/CachingClusteredClientTest.java    | 2 +-
 .../java/org/apache/druid/timeline/DataSegmentTest.java    | 4 ++--
 7 files changed, 10 insertions(+), 20 deletions(-)

diff --git a/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java b/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
index 835517117835..a3e8dd40b27e 100644
--- a/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
+++ b/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
@@ -172,7 +172,7 @@ public void testIdentifier()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getId()
+        segment.getId().toString()
     );
   }
 
@@ -188,7 +188,7 @@ public void testIdentifierWithZeroPartition()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getId()
+        segment.getId().toString()
     );
   }
 
@@ -204,7 +204,7 @@ public void testIdentifierWithNonzeroPartition()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z_7",
-        segment.getId()
+        segment.getId().toString()
     );
   }
 
diff --git a/indexing-hadoop/src/test/java/org/apache/druid/indexer/HadoopTuningConfigTest.java b/indexing-hadoop/src/test/java/org/apache/druid/indexer/HadoopTuningConfigTest.java
index d5fa7d2051ba..2d9c9e2b2227 100644
--- a/indexing-hadoop/src/test/java/org/apache/druid/indexer/HadoopTuningConfigTest.java
+++ b/indexing-hadoop/src/test/java/org/apache/druid/indexer/HadoopTuningConfigTest.java
@@ -24,7 +24,6 @@
 import com.google.common.collect.ImmutableMap;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.segment.IndexSpec;
-import org.joda.time.DateTime;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -69,7 +68,7 @@ public void testSerde() throws Exception
     Assert.assertEquals("/tmp/workingpath", actual.getWorkingPath());
     Assert.assertEquals("version", actual.getVersion());
     Assert.assertNotNull(actual.getPartitionsSpec());
-    Assert.assertEquals(ImmutableMap.<DateTime, List<HadoopyShardSpec>>of(), actual.getShardSpecs());
+    Assert.assertEquals(ImmutableMap.<Long, List<HadoopyShardSpec>>of(), actual.getShardSpecs());
     Assert.assertEquals(new IndexSpec(), actual.getIndexSpec());
     Assert.assertEquals(100, actual.getRowFlushBoundary());
     Assert.assertEquals(true, actual.isLeaveIntermediate());
diff --git a/processing/src/main/java/org/apache/druid/query/metadata/metadata/SegmentAnalysis.java b/processing/src/main/java/org/apache/druid/query/metadata/metadata/SegmentAnalysis.java
index 9cc805ec2218..726d51e1e86b 100644
--- a/processing/src/main/java/org/apache/druid/query/metadata/metadata/SegmentAnalysis.java
+++ b/processing/src/main/java/org/apache/druid/query/metadata/metadata/SegmentAnalysis.java
@@ -181,10 +181,6 @@ public int hashCode()
   @Override
   public int compareTo(SegmentAnalysis rhs)
   {
-    // Nulls first
-    if (rhs == null) {
-      return 1;
-    }
     return id.compareTo(rhs.getId());
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/guice/ExtensionsConfigTest.java b/processing/src/test/java/org/apache/druid/guice/ExtensionsConfigTest.java
index d5dd29addd6e..3d1c056a2d34 100644
--- a/processing/src/test/java/org/apache/druid/guice/ExtensionsConfigTest.java
+++ b/processing/src/test/java/org/apache/druid/guice/ExtensionsConfigTest.java
@@ -74,12 +74,7 @@ public void testSerdeWithNonDefaults() throws Exception
     Assert.assertEquals("testExtensions", config.getDirectory());
     Assert.assertEquals("testHadoopDependenciesDir", config.getHadoopDependenciesDir());
     Assert.assertEquals("testHadoopContainerClasspath", config.getHadoopContainerDruidClasspath());
-    Assert.assertEquals(
-        ImmutableList.of(
-            "b", "a"
-        ),
-            new ArrayList<>(config.getLoadList())
-    );
+    Assert.assertEquals(ImmutableList.of("b", "a"), new ArrayList<>(config.getLoadList()));
   }
   @Test
   public void testLoadList() throws Exception
diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
index 6bb8cc1d10bf..1fcf16d8df36 100644
--- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
@@ -67,7 +67,7 @@ private void testIncrementalWorksHelper(EnumSet<SegmentMetadataQuery.AnalysisTyp
     Assert.assertEquals(1, results.size());
 
     final SegmentAnalysis analysis = results.get(0);
-    Assert.assertEquals(null, analysis.getId());
+    Assert.assertEquals(SegmentId.dummy("ds").toString(), analysis.getId());
 
     final Map<String, ColumnAnalysis> columns = analysis.getColumns();
 
@@ -126,7 +126,7 @@ private void testMappedWorksHelper(EnumSet<SegmentMetadataQuery.AnalysisType> an
     Assert.assertEquals(1, results.size());
 
     final SegmentAnalysis analysis = results.get(0);
-    Assert.assertEquals("test_1", analysis.getId());
+    Assert.assertEquals(SegmentId.dummy("test_1").toString(), analysis.getId());
 
     final Map<String, ColumnAnalysis> columns = analysis.getColumns();
     Assert.assertEquals(
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
index d97a514ae7d3..155dbaf9720d 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
@@ -733,7 +733,7 @@ public void testDisableUseCache()
     Assert.assertEquals(0, cache.getStats().getNumHits());
     Assert.assertEquals(0, cache.getStats().getNumMisses());
 
-    cache.close("0_0");
+    cache.close(SegmentId.dummy("0_0").toString());
 
     testQueryCaching(
         runner,
diff --git a/server/src/test/java/org/apache/druid/timeline/DataSegmentTest.java b/server/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
index ad7524988726..28c5db844f19 100644
--- a/server/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
+++ b/server/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
@@ -47,7 +47,7 @@
  */
 public class DataSegmentTest
 {
-  final ObjectMapper mapper = new DefaultObjectMapper();
+  private final ObjectMapper mapper = new DefaultObjectMapper();
 
   @Before
   public void setUp()
@@ -126,7 +126,7 @@ public void testId()
 
     Assert.assertEquals(
         "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getId()
+        segment.getId().toString()
     );
   }
 

From 2684edb5864d4db172eefc39820dde10fcaadd8e Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Mon, 1 Oct 2018 15:56:09 -0300
Subject: [PATCH 10/27] Remove duplicate DataSegmentTest, fixes #6064

---
 .../druid/timeline/DataSegmentTest.java       | 263 ------------------
 1 file changed, 263 deletions(-)
 delete mode 100644 api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java

diff --git a/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java b/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
deleted file mode 100644
index a3e8dd40b27e..000000000000
--- a/api/src/test/java/org/apache/druid/timeline/DataSegmentTest.java
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.apache.druid.timeline;
-
-import com.fasterxml.jackson.databind.InjectableValues;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.RangeSet;
-import com.google.common.collect.Sets;
-import org.apache.druid.TestObjectMapper;
-import org.apache.druid.data.input.InputRow;
-import org.apache.druid.java.util.common.DateTimes;
-import org.apache.druid.java.util.common.Intervals;
-import org.apache.druid.java.util.common.jackson.JacksonUtils;
-import org.apache.druid.timeline.partition.NoneShardSpec;
-import org.apache.druid.timeline.partition.PartitionChunk;
-import org.apache.druid.timeline.partition.ShardSpec;
-import org.apache.druid.timeline.partition.ShardSpecLookup;
-import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- */
-public class DataSegmentTest
-{
-  private static final ObjectMapper mapper = new TestObjectMapper();
-  private static final int TEST_VERSION = 0x7;
-
-  private static ShardSpec getShardSpec(final int partitionNum)
-  {
-    return new ShardSpec()
-    {
-      @Override
-      public <T> PartitionChunk<T> createChunk(T obj)
-      {
-        return null;
-      }
-
-      @Override
-      public boolean isInChunk(long timestamp, InputRow inputRow)
-      {
-        return false;
-      }
-
-      @Override
-      public int getPartitionNum()
-      {
-        return partitionNum;
-      }
-
-      @Override
-      public ShardSpecLookup getLookup(List<ShardSpec> shardSpecs)
-      {
-        return null;
-      }
-
-      @Override
-      public List<String> getDomainDimensions()
-      {
-        return ImmutableList.of();
-      }
-
-      @Override
-      public boolean possibleInDomain(Map<String, RangeSet<String>> domain)
-      {
-        return true;
-      }
-    };
-  }
-
-  @Before
-  public void setUp()
-  {
-    InjectableValues.Std injectableValues = new InjectableValues.Std();
-    injectableValues.addValue(DataSegment.PruneLoadSpecHolder.class, DataSegment.PruneLoadSpecHolder.DEFAULT);
-    mapper.setInjectableValues(injectableValues);
-  }
-
-  @Test
-  public void testV1Serialization() throws Exception
-  {
-
-    final Interval interval = Intervals.of("2011-10-01/2011-10-02");
-    final ImmutableMap<String, Object> loadSpec = ImmutableMap.of("something", "or_other");
-
-    DataSegment segment = new DataSegment(
-        "something",
-        interval,
-        "1",
-        loadSpec,
-        Arrays.asList("dim1", "dim2"),
-        Arrays.asList("met1", "met2"),
-        NoneShardSpec.instance(),
-        TEST_VERSION,
-        1
-    );
-
-    final Map<String, Object> objectMap = mapper.readValue(
-        mapper.writeValueAsString(segment),
-        JacksonUtils.TYPE_REFERENCE_MAP_STRING_OBJECT
-    );
-
-    Assert.assertEquals(10, objectMap.size());
-    Assert.assertEquals("something", objectMap.get("dataSource"));
-    Assert.assertEquals(interval.toString(), objectMap.get("interval"));
-    Assert.assertEquals("1", objectMap.get("version"));
-    Assert.assertEquals(loadSpec, objectMap.get("loadSpec"));
-    Assert.assertEquals("dim1,dim2", objectMap.get("dimensions"));
-    Assert.assertEquals("met1,met2", objectMap.get("metrics"));
-    Assert.assertEquals(ImmutableMap.of("type", "none"), objectMap.get("shardSpec"));
-    Assert.assertEquals(TEST_VERSION, objectMap.get("binaryVersion"));
-    Assert.assertEquals(1, objectMap.get("size"));
-
-    DataSegment deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
-
-    Assert.assertEquals(segment.getDataSource(), deserializedSegment.getDataSource());
-    Assert.assertEquals(segment.getInterval(), deserializedSegment.getInterval());
-    Assert.assertEquals(segment.getVersion(), deserializedSegment.getVersion());
-    Assert.assertEquals(segment.getLoadSpec(), deserializedSegment.getLoadSpec());
-    Assert.assertEquals(segment.getDimensions(), deserializedSegment.getDimensions());
-    Assert.assertEquals(segment.getMetrics(), deserializedSegment.getMetrics());
-    Assert.assertEquals(segment.getShardSpec(), deserializedSegment.getShardSpec());
-    Assert.assertEquals(segment.getSize(), deserializedSegment.getSize());
-    Assert.assertEquals(segment.getId(), deserializedSegment.getId());
-
-    deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
-    Assert.assertEquals(0, segment.compareTo(deserializedSegment));
-
-    deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
-    Assert.assertEquals(0, deserializedSegment.compareTo(segment));
-
-    deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
-    Assert.assertEquals(segment.hashCode(), deserializedSegment.hashCode());
-  }
-
-  @Test
-  public void testIdentifier()
-  {
-    final DataSegment segment = DataSegment.builder()
-                                           .dataSource("foo")
-                                           .interval(Intervals.of("2012-01-01/2012-01-02"))
-                                           .version(DateTimes.of("2012-01-01T11:22:33.444Z").toString())
-                                           .shardSpec(NoneShardSpec.instance())
-                                           .build();
-
-    Assert.assertEquals(
-        "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getId().toString()
-    );
-  }
-
-  @Test
-  public void testIdentifierWithZeroPartition()
-  {
-    final DataSegment segment = DataSegment.builder()
-                                           .dataSource("foo")
-                                           .interval(Intervals.of("2012-01-01/2012-01-02"))
-                                           .version(DateTimes.of("2012-01-01T11:22:33.444Z").toString())
-                                           .shardSpec(getShardSpec(0))
-                                           .build();
-
-    Assert.assertEquals(
-        "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z",
-        segment.getId().toString()
-    );
-  }
-
-  @Test
-  public void testIdentifierWithNonzeroPartition()
-  {
-    final DataSegment segment = DataSegment.builder()
-                                           .dataSource("foo")
-                                           .interval(Intervals.of("2012-01-01/2012-01-02"))
-                                           .version(DateTimes.of("2012-01-01T11:22:33.444Z").toString())
-                                           .shardSpec(getShardSpec(7))
-                                           .build();
-
-    Assert.assertEquals(
-        "foo_2012-01-01T00:00:00.000Z_2012-01-02T00:00:00.000Z_2012-01-01T11:22:33.444Z_7",
-        segment.getId().toString()
-    );
-  }
-
-  @Test
-  public void testV1SerializationNullMetrics() throws Exception
-  {
-    final DataSegment segment = DataSegment.builder()
-                                           .dataSource("foo")
-                                           .interval(Intervals.of("2012-01-01/2012-01-02"))
-                                           .version(DateTimes.of("2012-01-01T11:22:33.444Z").toString())
-                                           .build();
-
-    final DataSegment segment2 = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
-    Assert.assertEquals("empty dimensions", ImmutableList.of(), segment2.getDimensions());
-    Assert.assertEquals("empty metrics", ImmutableList.of(), segment2.getMetrics());
-  }
-
-  @Test
-  public void testBucketMonthComparator()
-  {
-    DataSegment[] sortedOrder = {
-        makeDataSegment("test1", "2011-01-01/2011-01-02", "a"),
-        makeDataSegment("test1", "2011-01-02/2011-01-03", "a"),
-        makeDataSegment("test1", "2011-01-02/2011-01-03", "b"),
-        makeDataSegment("test2", "2011-01-01/2011-01-02", "a"),
-        makeDataSegment("test2", "2011-01-02/2011-01-03", "a"),
-        makeDataSegment("test1", "2011-02-01/2011-02-02", "a"),
-        makeDataSegment("test1", "2011-02-02/2011-02-03", "a"),
-        makeDataSegment("test1", "2011-02-02/2011-02-03", "b"),
-        makeDataSegment("test2", "2011-02-01/2011-02-02", "a"),
-        makeDataSegment("test2", "2011-02-02/2011-02-03", "a"),
-    };
-
-    List<DataSegment> shuffled = new ArrayList<>(Arrays.asList(sortedOrder));
-    Collections.shuffle(shuffled);
-
-    Set<DataSegment> theSet = Sets.newTreeSet(DataSegment.bucketMonthComparator());
-    theSet.addAll(shuffled);
-
-    int index = 0;
-    for (DataSegment dataSegment : theSet) {
-      Assert.assertEquals(sortedOrder[index], dataSegment);
-      ++index;
-    }
-  }
-
-  private DataSegment makeDataSegment(String dataSource, String interval, String version)
-  {
-    return DataSegment.builder()
-                      .dataSource(dataSource)
-                      .interval(Intervals.of(interval))
-                      .version(version)
-                      .size(1)
-                      .build();
-  }
-}

From 0a10fc306a42b67ae0660129b238744f56ba5041 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Mon, 1 Oct 2018 16:01:35 -0300
Subject: [PATCH 11/27] SegmentDescriptor doc

---
 .../main/java/org/apache/druid/query/SegmentDescriptor.java  | 5 ++++-
 api/src/main/java/org/apache/druid/timeline/DataSegment.java | 4 +++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/api/src/main/java/org/apache/druid/query/SegmentDescriptor.java b/api/src/main/java/org/apache/druid/query/SegmentDescriptor.java
index 6932dd19df3e..4a9e666718be 100644
--- a/api/src/main/java/org/apache/druid/query/SegmentDescriptor.java
+++ b/api/src/main/java/org/apache/druid/query/SegmentDescriptor.java
@@ -24,7 +24,10 @@
 import org.joda.time.Interval;
 
 /**
-*/
+ * The difference between this class and {@link org.apache.druid.timeline.DataSegment} is that this class is a "light"
+ * version of {@link org.apache.druid.timeline.DataSegment}, that only contains the interval, version, and partition
+ * number. SegmentDescriptor is used when Brokers tell data servers which segments to include for a particular query.
+ */
 public class SegmentDescriptor
 {
   private final Interval interval;
diff --git a/api/src/main/java/org/apache/druid/timeline/DataSegment.java b/api/src/main/java/org/apache/druid/timeline/DataSegment.java
index 080b7e576bd8..08310c7ee48f 100644
--- a/api/src/main/java/org/apache/druid/timeline/DataSegment.java
+++ b/api/src/main/java/org/apache/druid/timeline/DataSegment.java
@@ -62,7 +62,9 @@ public class DataSegment implements Comparable<DataSegment>
    * The difference between this class and org.apache.druid.segment.Segment is that this class contains the segment
    * metadata only, while org.apache.druid.segment.Segment represents the actual body of segment data, queryable.
    *
-   * TODO explain the difference with org.apache.druid.query.SegmentDescriptor
+   * The difference between this class and org.apache.druid.query.SegmentDescriptor is that SegmentDescriptor is
+   * a "light" version of DataSegment that only contains the interval, version, and partition number. SegmentDescriptor
+   * is used when Brokers tell data servers which segments to include for a particular query.
    */
 
   /**

From 33f5ae04c4ff15dc9a344d058403e9f3da4f699e Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Mon, 1 Oct 2018 16:52:36 -0300
Subject: [PATCH 12/27] Fix SQLMetadataStorageUpdaterJobHandler

---
 .../druid/indexer/SQLMetadataStorageUpdaterJobHandler.java      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/src/main/java/org/apache/druid/indexer/SQLMetadataStorageUpdaterJobHandler.java b/server/src/main/java/org/apache/druid/indexer/SQLMetadataStorageUpdaterJobHandler.java
index c3728762979b..71c2cadb105b 100644
--- a/server/src/main/java/org/apache/druid/indexer/SQLMetadataStorageUpdaterJobHandler.java
+++ b/server/src/main/java/org/apache/druid/indexer/SQLMetadataStorageUpdaterJobHandler.java
@@ -68,7 +68,7 @@ public Void withHandle(Handle handle) throws Exception
 
               batch.add(
                   new ImmutableMap.Builder<String, Object>()
-                      .put("id", segment.getId())
+                      .put("id", segment.getId().toString())
                       .put("dataSource", segment.getDataSource())
                       .put("created_date", DateTimes.nowUtc().toString())
                       .put("start", segment.getInterval().getStart().toString())

From 74b947f9ca4e181bdff52a312917bfa693efdaae Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Tue, 2 Oct 2018 12:46:58 -0300
Subject: [PATCH 13/27] Fix DataSegment deserialization for ignoring id

---
 api/src/main/java/org/apache/druid/timeline/DataSegment.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/api/src/main/java/org/apache/druid/timeline/DataSegment.java b/api/src/main/java/org/apache/druid/timeline/DataSegment.java
index 08310c7ee48f..38ee5f886507 100644
--- a/api/src/main/java/org/apache/druid/timeline/DataSegment.java
+++ b/api/src/main/java/org/apache/druid/timeline/DataSegment.java
@@ -248,7 +248,8 @@ public long getSize()
     return size;
   }
 
-  @JsonProperty("identifier") // matching the established public HTTP JSON API
+  // "identifier" for backward compatibility of JSON API
+  @JsonProperty(value = "identifier", access = JsonProperty.Access.READ_ONLY)
   public SegmentId getId()
   {
     return id;

From 24dd181933c2dad77731182ace519d3f3dd59a1f Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Wed, 10 Oct 2018 14:48:06 -0300
Subject: [PATCH 14/27] Add comments

---
 .../org/apache/druid/timeline/SegmentId.java    |  1 +
 .../apache/druid/timeline/SegmentIdTest.java    | 17 +++++++++++++++--
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/api/src/main/java/org/apache/druid/timeline/SegmentId.java b/api/src/main/java/org/apache/druid/timeline/SegmentId.java
index f07a95227605..b6f3ba5cc03f 100644
--- a/api/src/main/java/org/apache/druid/timeline/SegmentId.java
+++ b/api/src/main/java/org/apache/druid/timeline/SegmentId.java
@@ -267,6 +267,7 @@ private int computeHashCode()
     // Start with partitionNum and version hash codes, because they are often little sequential numbers. If they are
     // added in the end of the chain, resulting hashCode of SegmentId could have worse distribution.
     int hashCode = partitionNum;
+    // 1000003 is a constant used in Google AutoValue, provides a little better distribution than 31
     hashCode = hashCode * 1000003 + version.hashCode();
 
     hashCode = hashCode * 1000003 + dataSource.hashCode();
diff --git a/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java b/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
index ffbd7d311d8b..3f2b6dbd300f 100644
--- a/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
+++ b/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
@@ -56,7 +56,7 @@ public void testBasic()
   }
 
   @Test
-  public void testDataSourceWithUnderscore1()
+  public void testDataSourceWithUnderscore()
   {
     String datasource = "datasource_1";
     SegmentId desc = SegmentId.of(datasource, Intervals.of("2015-01-02/2015-01-03"), "ver_0", 1);
@@ -76,8 +76,12 @@ public void testDataSourceWithUnderscore1()
     Assert.assertEquals(desc, SegmentId.tryParse(datasource, desc.toString()));
   }
 
+  /**
+   * Test the ambiguity of a datasource name ending with '_yyyy-mm-dd..' string that could be considered either as the
+   * end of the datasource name or the interval start in the segment id's string representation.
+   */
   @Test
-  public void testDataSourceWithUnderscore2()
+  public void testDataSourceWithUnderscoreAndTimeStringInDataSourceName()
   {
     String dataSource = "datasource_2015-01-01T00:00:00.000Z";
     SegmentId desc = SegmentId.of(dataSource, Intervals.of("2015-01-02/2015-01-03"), "ver_0", 1);
@@ -109,18 +113,27 @@ public void testDataSourceWithUnderscore2()
     Assert.assertEquals(desc, SegmentId.tryParse(dataSource, desc.toString()));
   }
 
+  /**
+   * The interval start is later than the end
+   */
   @Test
   public void testInvalidFormat0()
   {
     Assert.assertNull(SegmentId.tryParse("ds", "datasource_2015-01-02T00:00:00.000Z_2014-10-20T00:00:00.000Z_version"));
   }
 
+  /**
+   * No interval dates
+   */
   @Test
   public void testInvalidFormat1()
   {
     Assert.assertNull(SegmentId.tryParse("datasource", "datasource_invalid_interval_version"));
   }
 
+  /**
+   * Not enough interval dates
+   */
   @Test
   public void testInvalidFormat2()
   {

From 78f60740fa58293c7e76ccd1e92f98d21fe93b08 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Wed, 10 Oct 2018 15:02:29 -0300
Subject: [PATCH 15/27] More comments

---
 .../java/org/apache/druid/metadata/MetadataSegmentManager.java | 3 +++
 .../org/apache/druid/metadata/SQLMetadataSegmentManager.java   | 1 +
 2 files changed, 4 insertions(+)

diff --git a/server/src/main/java/org/apache/druid/metadata/MetadataSegmentManager.java b/server/src/main/java/org/apache/druid/metadata/MetadataSegmentManager.java
index 195ae13998cb..e33e35439459 100644
--- a/server/src/main/java/org/apache/druid/metadata/MetadataSegmentManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/MetadataSegmentManager.java
@@ -44,6 +44,9 @@ public interface MetadataSegmentManager
 
   /**
    * Prefer {@link #removeSegment(SegmentId)} to this method when possible.
+   *
+   * This method is not removed because {@link org.apache.druid.server.http.DataSourcesResource#deleteDatasourceSegment}
+   * uses it and if it migrates to {@link #removeSegment(SegmentId)} the performance will be worse.
    */
   boolean removeSegment(String dataSource, String segmentId);
 
diff --git a/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java b/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
index 0daa395456c1..dc55ad4ef1d7 100644
--- a/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
@@ -466,6 +466,7 @@ public List<String> fold(
   @Override
   public void poll()
   {
+    // See the comment to the pollLock field, explaining this synchronized block
     synchronized (pollLock) {
       try {
         doPoll();

From 62afb7d3087ade74b37ee5cd6f622ec05cb26f08 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Thu, 11 Oct 2018 14:21:28 -0300
Subject: [PATCH 16/27] Address more comments

---
 .../org/apache/druid/timeline/SegmentId.java  |  3 ++
 .../apache/druid/timeline/SegmentIdTest.java  | 41 ++++++++++++++++++-
 .../metadata/SQLMetadataSegmentManager.java   |  2 +
 3 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/api/src/main/java/org/apache/druid/timeline/SegmentId.java b/api/src/main/java/org/apache/druid/timeline/SegmentId.java
index b6f3ba5cc03f..f4a39729c1aa 100644
--- a/api/src/main/java/org/apache/druid/timeline/SegmentId.java
+++ b/api/src/main/java/org/apache/druid/timeline/SegmentId.java
@@ -174,6 +174,9 @@ public static List<SegmentId> iteratePossibleParsingsWithDataSource(String dataS
     catch (IllegalArgumentException e) {
       return Collections.emptyList();
     }
+    if (start.compareTo(end) >= 0) {
+      return Collections.emptyList();
+    }
     List<SegmentId> possibleParsings = new ArrayList<>(2);
     String version = DELIMITER_JOINER.join(splits.subList(2, Math.max(splits.size() - 1, 3)));
     String trail = splits.size() > 3 ? splits.get(splits.size() - 1) : null;
diff --git a/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java b/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
index 3f2b6dbd300f..48075c33bfb6 100644
--- a/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
+++ b/api/src/test/java/org/apache/druid/timeline/SegmentIdTest.java
@@ -119,7 +119,9 @@ public void testDataSourceWithUnderscoreAndTimeStringInDataSourceName()
   @Test
   public void testInvalidFormat0()
   {
-    Assert.assertNull(SegmentId.tryParse("ds", "datasource_2015-01-02T00:00:00.000Z_2014-10-20T00:00:00.000Z_version"));
+    Assert.assertNull(
+        SegmentId.tryParse("datasource", "datasource_2015-01-02T00:00:00.000Z_2014-10-20T00:00:00.000Z_version")
+    );
   }
 
   /**
@@ -189,4 +191,41 @@ public void testIterateAllPossibleParsings()
     Assert.assertEquals(4, possibleParsings.size());
     Assert.assertEquals(expected, ImmutableSet.copyOf(possibleParsings));
   }
+
+  @Test
+  public void testIterateAllPossibleParsingsWithEmptyVersion()
+  {
+    String segmentId = "datasource_2015-01-01T00:00:00.000Z_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z__1";
+    List<SegmentId> possibleParsings = ImmutableList.copyOf(SegmentId.iterateAllPossibleParsings(segmentId));
+    DateTime dt1 = DateTimes.of("2015-01-01T00:00:00.000Z");
+    DateTime dt2 = DateTimes.of("2015-01-02T00:00:00.000Z");
+    DateTime dt3 = DateTimes.of("2015-01-03T00:00:00.000Z");
+    Set<SegmentId> expected = ImmutableSet.of(
+        SegmentId.of("datasource", new Interval(dt1, dt2), "2015-01-03T00:00:00.000Z_", 1),
+        SegmentId.of("datasource", new Interval(dt1, dt2), "2015-01-03T00:00:00.000Z__1", 0),
+        SegmentId.of("datasource_2015-01-01T00:00:00.000Z", new Interval(dt2, dt3), "", 1),
+        SegmentId.of("datasource_2015-01-01T00:00:00.000Z", new Interval(dt2, dt3), "_1", 0)
+    );
+    Assert.assertEquals(4, possibleParsings.size());
+    Assert.assertEquals(expected, ImmutableSet.copyOf(possibleParsings));
+  }
+
+  /**
+   * Three DateTime strings included, but not ascending, that makes a pair of parsings impossible, compared to {@link
+   * #testIterateAllPossibleParsings}.
+   */
+  @Test
+  public void testIterateAllPossibleParsings2()
+  {
+    String segmentId = "datasource_2015-01-02T00:00:00.000Z_2015-01-03T00:00:00.000Z_2015-01-02T00:00:00.000Z_ver_1";
+    List<SegmentId> possibleParsings = ImmutableList.copyOf(SegmentId.iterateAllPossibleParsings(segmentId));
+    DateTime dt1 = DateTimes.of("2015-01-02T00:00:00.000Z");
+    DateTime dt2 = DateTimes.of("2015-01-03T00:00:00.000Z");
+    Set<SegmentId> expected = ImmutableSet.of(
+        SegmentId.of("datasource", new Interval(dt1, dt2), "2015-01-02T00:00:00.000Z_ver", 1),
+        SegmentId.of("datasource", new Interval(dt1, dt2), "2015-01-02T00:00:00.000Z_ver_1", 0)
+    );
+    Assert.assertEquals(2, possibleParsings.size());
+    Assert.assertEquals(expected, ImmutableSet.copyOf(possibleParsings));
+  }
 }
diff --git a/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java b/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
index dc55ad4ef1d7..f1ba0df17445 100644
--- a/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
+++ b/server/src/main/java/org/apache/druid/metadata/SQLMetadataSegmentManager.java
@@ -177,6 +177,8 @@ private Runnable createPollTaskForStartOrder(long startOrder)
       try {
         if (startOrder == currentStartOrder) {
           poll();
+        } else {
+          log.debug("startOrder = currentStartOrder = %d, skipping poll()", startOrder);
         }
       }
       catch (Exception e) {

From 629726151baae4db79ddca2e1034ad3c723d0b74 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Thu, 11 Oct 2018 15:10:26 -0300
Subject: [PATCH 17/27] Fix compilation

---
 .../druid/server/http/MetadataResource.java   |  6 +-
 .../sql/calcite/schema/SystemSchema.java      | 78 ++++++++++---------
 .../sql/calcite/schema/SystemSchemaTest.java  | 42 ++++------
 3 files changed, 58 insertions(+), 68 deletions(-)

diff --git a/server/src/main/java/org/apache/druid/server/http/MetadataResource.java b/server/src/main/java/org/apache/druid/server/http/MetadataResource.java
index dbb5986583d3..47a41efbb8c7 100644
--- a/server/src/main/java/org/apache/druid/server/http/MetadataResource.java
+++ b/server/src/main/java/org/apache/druid/server/http/MetadataResource.java
@@ -134,9 +134,7 @@ public Response getDatabaseDataSources(
   @Path("/datasources/{dataSourceName}")
   @Produces(MediaType.APPLICATION_JSON)
   @ResourceFilters(DatasourceResourceFilter.class)
-  public Response getDatabaseSegmentDataSource(
-      @PathParam("dataSourceName") final String dataSourceName
-  )
+  public Response getDatabaseSegmentDataSource(@PathParam("dataSourceName") final String dataSourceName)
   {
     ImmutableDruidDataSource dataSource = metadataSegmentManager.getDataSource(dataSourceName);
     if (dataSource == null) {
@@ -151,7 +149,7 @@ public Response getDatabaseSegmentDataSource(
   @Produces(MediaType.APPLICATION_JSON)
   public Response getDatabaseSegments(@Context final HttpServletRequest req)
   {
-    final Collection<ImmutableDruidDataSource> druidDataSources = metadataSegmentManager.getInventory();
+    final Collection<ImmutableDruidDataSource> druidDataSources = metadataSegmentManager.getDataSources();
     final Set<DataSegment> metadataSegments = druidDataSources
         .stream()
         .flatMap(t -> t.getSegments().stream())
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/SystemSchema.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/SystemSchema.java
index da34bbeeacd7..293a087cf460 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/SystemSchema.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/SystemSchema.java
@@ -47,8 +47,8 @@
 import org.apache.druid.client.indexing.IndexingService;
 import org.apache.druid.discovery.DruidLeaderClient;
 import org.apache.druid.indexer.TaskStatusPlus;
+import org.apache.druid.java.util.common.RE;
 import org.apache.druid.java.util.common.StringUtils;
-import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.java.util.common.parsers.CloseableIterator;
 import org.apache.druid.java.util.http.client.Request;
 import org.apache.druid.segment.column.ValueType;
@@ -65,6 +65,7 @@
 import org.apache.druid.sql.calcite.planner.PlannerContext;
 import org.apache.druid.sql.calcite.table.RowSignature;
 import org.apache.druid.timeline.DataSegment;
+import org.apache.druid.timeline.SegmentId;
 import org.jboss.netty.handler.codec.http.HttpMethod;
 
 import java.io.IOException;
@@ -76,12 +77,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.Set;
 
 public class SystemSchema extends AbstractSchema
 {
-  private static final Logger log = new Logger(SystemSchema.class);
-
   public static final String NAME = "sys";
   private static final String SEGMENTS_TABLE = "segments";
   private static final String SERVERS_TABLE = "servers";
@@ -154,8 +154,15 @@ public SystemSchema(
   {
     Preconditions.checkNotNull(serverView, "serverView");
     BytesAccumulatingResponseHandler responseHandler = new BytesAccumulatingResponseHandler();
+    SegmentsTable segmentsTable = new SegmentsTable(
+        druidSchema,
+        coordinatorDruidLeaderClient,
+        jsonMapper,
+        responseHandler,
+        authorizerMapper
+    );
     this.tableMap = ImmutableMap.of(
-        SEGMENTS_TABLE, new SegmentsTable(druidSchema, coordinatorDruidLeaderClient, jsonMapper, responseHandler, authorizerMapper),
+        SEGMENTS_TABLE, segmentsTable,
         SERVERS_TABLE, new ServersTable(serverView, authorizerMapper),
         SERVER_SEGMENTS_TABLE, new ServerSegmentsTable(serverView, authorizerMapper),
         TASKS_TABLE, new TasksTable(overlordDruidLeaderClient, jsonMapper, responseHandler, authorizerMapper)
@@ -208,8 +215,8 @@ public Enumerable<Object[]> scan(DataContext root)
     {
       //get available segments from druidSchema
       final Map<DataSegment, SegmentMetadataHolder> availableSegmentMetadata = druidSchema.getSegmentMetadata();
-      final Iterator<Entry<DataSegment, SegmentMetadataHolder>> availableSegmentEntries = availableSegmentMetadata.entrySet()
-                                                                                                                  .iterator();
+      final Iterator<Entry<DataSegment, SegmentMetadataHolder>> availableSegmentEntries =
+          availableSegmentMetadata.entrySet().iterator();
 
       //get published segments from coordinator
       final JsonParserIterator<DataSegment> metadataSegments = getMetadataSegments(
@@ -218,22 +225,20 @@ public Enumerable<Object[]> scan(DataContext root)
           responseHandler
       );
 
-      Set<String> availableSegmentIds = new HashSet<>();
+      Set<SegmentId> availableSegmentIds = new HashSet<>();
       //auth check for available segments
-      final Iterator<Entry<DataSegment, SegmentMetadataHolder>> authorizedAvailableSegments = getAuthorizedAvailableSegments(
-          availableSegmentEntries,
-          root
-      );
+      final Iterator<Entry<DataSegment, SegmentMetadataHolder>> authorizedAvailableSegments =
+          getAuthorizedAvailableSegments(availableSegmentEntries, root);
 
       final FluentIterable<Object[]> availableSegments = FluentIterable
           .from(() -> authorizedAvailableSegments)
           .transform(val -> {
             try {
-              if (!availableSegmentIds.contains(val.getKey().getIdentifier())) {
-                availableSegmentIds.add(val.getKey().getIdentifier());
+              if (!availableSegmentIds.contains(val.getKey().getId())) {
+                availableSegmentIds.add(val.getKey().getId());
               }
               return new Object[]{
-                  val.getKey().getIdentifier(),
+                  val.getKey().getId(),
                   val.getKey().getDataSource(),
                   val.getKey().getInterval().getStart(),
                   val.getKey().getInterval().getEnd(),
@@ -249,10 +254,7 @@ public Enumerable<Object[]> scan(DataContext root)
               };
             }
             catch (JsonProcessingException e) {
-              throw new RuntimeException(StringUtils.format(
-                  "Error getting segment payload for segment %s",
-                  val.getKey().getIdentifier()
-              ), e);
+              throw new RE(e, "Error getting segment payload for segment %s", val.getKey().getId());
             }
           });
 
@@ -265,11 +267,11 @@ public Enumerable<Object[]> scan(DataContext root)
           .from(() -> authorizedPublishedSegments)
           .transform(val -> {
             try {
-              if (availableSegmentIds.contains(val.getIdentifier())) {
+              if (availableSegmentIds.contains(val.getId())) {
                 return null;
               }
               return new Object[]{
-                  val.getIdentifier(),
+                  val.getId(),
                   val.getDataSource(),
                   val.getInterval().getStart(),
                   val.getInterval().getEnd(),
@@ -285,17 +287,14 @@ public Enumerable<Object[]> scan(DataContext root)
               };
             }
             catch (JsonProcessingException e) {
-              throw new RuntimeException(StringUtils.format(
-                  "Error getting segment payload for segment %s",
-                  val.getIdentifier()
-              ), e);
+              throw new RE(e, "Error getting segment payload for segment %s", val.getId());
             }
           });
 
       final Iterable<Object[]> allSegments = Iterables.unmodifiableIterable(
           Iterables.concat(availableSegments, publishedSegments));
 
-      return Linq4j.asEnumerable(allSegments).where(t -> t != null);
+      return Linq4j.asEnumerable(allSegments).where(Objects::nonNull);
 
     }
 
@@ -310,8 +309,13 @@ private Iterator<Entry<DataSegment, SegmentMetadataHolder>> getAuthorizedAvailab
       Function<Entry<DataSegment, SegmentMetadataHolder>, Iterable<ResourceAction>> raGenerator = segment -> Collections
           .singletonList(AuthorizationUtils.DATASOURCE_READ_RA_GENERATOR.apply(segment.getKey().getDataSource()));
 
-      final Iterable<Entry<DataSegment, SegmentMetadataHolder>> authorizedSegments = AuthorizationUtils.filterAuthorizedResources(
-          authenticationResult, () -> availableSegmentEntries, raGenerator, authorizerMapper);
+      final Iterable<Entry<DataSegment, SegmentMetadataHolder>> authorizedSegments =
+          AuthorizationUtils.filterAuthorizedResources(
+              authenticationResult,
+              () -> availableSegmentEntries,
+              raGenerator,
+              authorizerMapper
+          );
 
       return authorizedSegments.iterator();
     }
@@ -328,7 +332,11 @@ private CloseableIterator<DataSegment> getAuthorizedPublishedSegments(
           AuthorizationUtils.DATASOURCE_READ_RA_GENERATOR.apply(segment.getDataSource()));
 
       final Iterable<DataSegment> authorizedSegments = AuthorizationUtils.filterAuthorizedResources(
-          authenticationResult, () -> it, raGenerator, authorizerMapper);
+          authenticationResult,
+          () -> it,
+          raGenerator,
+          authorizerMapper
+      );
 
       return wrap(authorizedSegments.iterator(), it);
     }
@@ -452,11 +460,10 @@ public Enumerable<Object[]> scan(DataContext root)
       final List<ImmutableDruidServer> druidServers = serverView.getDruidServers();
       final int serverSegmentsTableSize = SERVER_SEGMENTS_SIGNATURE.getRowOrder().size();
       for (ImmutableDruidServer druidServer : druidServers) {
-        final Map<String, DataSegment> segmentMap = druidServer.getSegments();
-        for (DataSegment segment : segmentMap.values()) {
+        for (DataSegment segment : druidServer.getSegments()) {
           Object[] row = new Object[serverSegmentsTableSize];
           row[0] = druidServer.getHost();
-          row[1] = segment.getIdentifier();
+          row[1] = segment.getId();
           rows.add(row);
         }
       }
@@ -533,8 +540,7 @@ public Object[] current()
                                   task.getDuration(),
                                   task.getLocation().getHost() + ":" + (task.getLocation().getTlsPort()
                                                                           == -1
-                                                                          ? task.getLocation()
-                                                                                .getPort()
+                                                                          ? task.getLocation().getPort()
                                                                           : task.getLocation().getTlsPort()),
                                   task.getLocation().getHost(),
                                   task.getLocation().getPort(),
@@ -571,7 +577,10 @@ public void close()
       return new TasksEnumerable(getTasks(druidLeaderClient, jsonMapper, responseHandler));
     }
 
-    private CloseableIterator<TaskStatusPlus> getAuthorizedTasks(JsonParserIterator<TaskStatusPlus> it, DataContext root)
+    private CloseableIterator<TaskStatusPlus> getAuthorizedTasks(
+        JsonParserIterator<TaskStatusPlus> it,
+        DataContext root
+    )
     {
       final AuthenticationResult authenticationResult =
           (AuthenticationResult) root.get(PlannerContext.DATA_CTX_AUTHENTICATION_RESULT);
@@ -594,7 +603,6 @@ private static JsonParserIterator<TaskStatusPlus> getTasks(
       BytesAccumulatingResponseHandler responseHandler
   )
   {
-
     Request request;
     try {
       request = indexingServiceClient.makeRequest(
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
index 9b9073344dc1..be34b4076902 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
@@ -34,24 +34,20 @@
 import org.apache.calcite.schema.SchemaPlus;
 import org.apache.calcite.schema.Table;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.druid.client.DirectDruidClient;
 import org.apache.druid.client.DruidServer;
+import org.apache.druid.client.ImmutableDruidDataSource;
 import org.apache.druid.client.ImmutableDruidServer;
 import org.apache.druid.client.TimelineServerView;
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.discovery.DruidLeaderClient;
-import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.Pair;
 import org.apache.druid.java.util.common.io.Closer;
-import org.apache.druid.java.util.http.client.HttpClient;
 import org.apache.druid.java.util.http.client.Request;
 import org.apache.druid.java.util.http.client.io.AppendableByteArrayInputStream;
 import org.apache.druid.java.util.http.client.response.FullResponseHolder;
 import org.apache.druid.java.util.http.client.response.HttpResponseHandler;
 import org.apache.druid.query.QueryRunnerFactoryConglomerate;
-import org.apache.druid.query.QueryRunnerTestHelper;
-import org.apache.druid.query.ReflectionQueryToolChestWarehouse;
 import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.aggregation.DoubleSumAggregatorFactory;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
@@ -64,7 +60,6 @@
 import org.apache.druid.server.coordination.DruidServerMetadata;
 import org.apache.druid.server.coordination.ServerType;
 import org.apache.druid.server.coordinator.BytesAccumulatingResponseHandler;
-import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.server.security.Access;
 import org.apache.druid.server.security.Authorizer;
 import org.apache.druid.server.security.AuthorizerMapper;
@@ -93,6 +88,8 @@
 import java.io.InputStream;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -284,37 +281,24 @@ public Authorizer getAuthorizer(String name)
       DataSegment.PruneLoadSpecHolder.DEFAULT
   );
 
-  private final HttpClient httpClient = EasyMock.createMock(HttpClient.class);
-  private final DirectDruidClient client1 = new DirectDruidClient(
-      new ReflectionQueryToolChestWarehouse(),
-      QueryRunnerTestHelper.NOOP_QUERYWATCHER,
-      new DefaultObjectMapper(),
-      httpClient,
-      "http",
-      "foo",
-      new NoopServiceEmitter()
-  );
-  private final DirectDruidClient client2 = new DirectDruidClient(
-      new ReflectionQueryToolChestWarehouse(),
-      QueryRunnerTestHelper.NOOP_QUERYWATCHER,
-      new DefaultObjectMapper(),
-      httpClient,
-      "http",
-      "foo2",
-      new NoopServiceEmitter()
-  );
   private final ImmutableDruidServer druidServer1 = new ImmutableDruidServer(
       new DruidServerMetadata("server1", "localhost:0000", null, 5L, ServerType.REALTIME, DruidServer.DEFAULT_TIER, 0),
       1L,
-      null,
-      ImmutableMap.of("segment1", segment1, "segment2", segment2)
+      ImmutableMap.of(
+          "dummy",
+          new ImmutableDruidDataSource("dummy", Collections.emptyMap(), Arrays.asList(segment1, segment2))
+      ),
+      2
   );
 
   private final ImmutableDruidServer druidServer2 = new ImmutableDruidServer(
       new DruidServerMetadata("server2", "server2:1234", null, 5L, ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
       1L,
-      null,
-      ImmutableMap.of("segment2", segment2, "segment4", segment4, "segment5", segment5)
+      ImmutableMap.of(
+          "dummy",
+          new ImmutableDruidDataSource("dummy", Collections.emptyMap(), Arrays.asList(segment3, segment4, segment5))
+      ),
+      3
   );
 
   private final List<ImmutableDruidServer> immutableDruidServers = ImmutableList.of(druidServer1, druidServer2);

From c1c296ec0ecadfa177e9f5ede3e642ad0d840710 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Fri, 12 Oct 2018 18:52:49 -0300
Subject: [PATCH 18/27] Restore segment2 in SystemSchemaTest according to a
 comment

---
 .../apache/druid/sql/calcite/schema/SystemSchemaTest.java    | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
index be34b4076902..cd847bc372c7 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
@@ -296,7 +296,10 @@ public Authorizer getAuthorizer(String name)
       1L,
       ImmutableMap.of(
           "dummy",
-          new ImmutableDruidDataSource("dummy", Collections.emptyMap(), Arrays.asList(segment3, segment4, segment5))
+          // It uses segment2 rather than segment3 because in testSegmentsTable() later, it asserts for 2 replicas
+          // for segment2. So it's trying to mimic the behavior that segment2 is served by both the servers druidServer1
+          // and druidServer2.
+          new ImmutableDruidDataSource("dummy", Collections.emptyMap(), Arrays.asList(segment2, segment4, segment5))
       ),
       3
   );

From c49b544c90105282e999e4c9574ac424e928fc0b Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Fri, 12 Oct 2018 20:44:49 -0300
Subject: [PATCH 19/27] Fix style

---
 .../java/org/apache/druid/sql/calcite/schema/DruidSchema.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
index bc0a762a5afa..a683a80f773d 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
@@ -328,7 +328,7 @@ private void addSegment(final DruidServerMetadata server, final DataSegment segm
         final long isRealtime = server.segmentReplicatable() ? 0 : 1;
         final long isPublished = server.getType() == ServerType.HISTORICAL ? 1 : 0;
         final SegmentMetadataHolder holder = SegmentMetadataHolder
-            .builder(segment.getId(), isPublished,1, isRealtime, 1)
+            .builder(segment.getId(), isPublished, 1, isRealtime, 1)
             .build();
         // Unknown segment.
         setSegmentSignature(segment, holder);

From f90df21778794eb56917834dbd7932e356cd160e Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Tue, 16 Oct 2018 13:19:40 -0300
Subject: [PATCH 20/27] fix testServerSegmentsTable

---
 .../sql/calcite/schema/SystemSchemaTest.java    | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
index 480f1e9c9150..a7a08cb16029 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
@@ -517,9 +517,10 @@ public Object get(String name)
   @Test
   public void testServerSegmentsTable()
   {
-    SystemSchema.ServerSegmentsTable serverSegmentsTable = EasyMock.createMockBuilder(SystemSchema.ServerSegmentsTable.class)
-                                                                   .withConstructor(serverView, authMapper)
-                                                                   .createMock();
+    SystemSchema.ServerSegmentsTable serverSegmentsTable = EasyMock
+        .createMockBuilder(SystemSchema.ServerSegmentsTable.class)
+        .withConstructor(serverView, authMapper)
+        .createMock();
     EasyMock.replay(serverSegmentsTable);
     EasyMock.expect(serverView.getDruidServers())
             .andReturn(immutableDruidServers)
@@ -567,27 +568,27 @@ public Object get(String name)
 
     Object[] row1 = rows.first();
     Assert.assertEquals("localhost:0000", row1[0]);
-    Assert.assertEquals("test1_2010-01-01T00:00:00.000Z_2011-01-01T00:00:00.000Z_version1", row1[1]);
+    Assert.assertEquals("test1_2010-01-01T00:00:00.000Z_2011-01-01T00:00:00.000Z_version1", row1[1].toString());
 
     Assert.assertEquals(true, enumerator.moveNext());
     Object[] row2 = enumerator.current();
     Assert.assertEquals("localhost:0000", row2[0]);
-    Assert.assertEquals("test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2", row2[1]);
+    Assert.assertEquals("test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2", row2[1].toString());
 
     Assert.assertEquals(true, enumerator.moveNext());
     Object[] row3 = enumerator.current();
     Assert.assertEquals("server2:1234", row3[0]);
-    Assert.assertEquals("test3_2012-01-01T00:00:00.000Z_2013-01-01T00:00:00.000Z_version3", row3[1]);
+    Assert.assertEquals("test3_2012-01-01T00:00:00.000Z_2013-01-01T00:00:00.000Z_version3", row3[1].toString());
 
     Assert.assertEquals(true, enumerator.moveNext());
     Object[] row4 = enumerator.current();
     Assert.assertEquals("server2:1234", row4[0]);
-    Assert.assertEquals("test4_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version4", row4[1]);
+    Assert.assertEquals("test4_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version4", row4[1].toString());
 
     Assert.assertEquals(true, enumerator.moveNext());
     Object[] row5 = rows.last();
     Assert.assertEquals("server2:1234", row5[0]);
-    Assert.assertEquals("test5_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version5", row5[1]);
+    Assert.assertEquals("test5_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version5", row5[1].toString());
 
     Assert.assertEquals(false, enumerator.moveNext());
   }

From 995b447d823cae00b409d262aa0afc64708efa78 Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Tue, 23 Oct 2018 09:10:48 -0300
Subject: [PATCH 21/27] Fix compilation

---
 .../groupby/NestedQueryPushDownTest.java      | 53 ++++---------------
 1 file changed, 11 insertions(+), 42 deletions(-)

diff --git a/processing/src/test/java/org/apache/druid/query/groupby/NestedQueryPushDownTest.java b/processing/src/test/java/org/apache/druid/query/groupby/NestedQueryPushDownTest.java
index 7f21731901f3..3042add4e60c 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/NestedQueryPushDownTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/NestedQueryPushDownTest.java
@@ -82,6 +82,7 @@
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.timeline.SegmentId;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -904,43 +905,14 @@ public void testQueryRewriteForPushDown()
     Assert.assertEquals(outputNameAgg, rewrittenQuery.getAggregatorSpecs().get(0).getName());
   }
 
-  private List<QueryRunner<Row>> getRunner1()
-  {
-    List<QueryRunner<Row>> runners = Lists.newArrayList();
-    QueryableIndex index = groupByIndices.get(0);
-    QueryRunner<Row> runner = makeQueryRunner(
-        groupByFactory,
-        index.toString(),
-        new QueryableIndexSegment(index.toString(), index)
-    );
-    runners.add(groupByFactory.getToolchest().preMergeQueryDecoration(runner));
-    return runners;
-  }
-
-  private List<QueryRunner<Row>> getRunner2()
-  {
-    List<QueryRunner<Row>> runners = Lists.newArrayList();
-    QueryableIndex index2 = groupByIndices.get(1);
-    QueryRunner<Row> tooSmallRunner = makeQueryRunner(
-        groupByFactory2,
-        index2.toString(),
-        new QueryableIndexSegment(index2.toString(), index2)
-    );
-    runners.add(groupByFactory2.getToolchest().preMergeQueryDecoration(tooSmallRunner));
-    return runners;
-  }
-
   public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner(
       QueryRunnerFactory<T, QueryType> factory,
-      String segmentId,
+      SegmentId segmentId,
       Segment adapter
   )
   {
-    return new FinalizeResultsQueryRunner<T>(
-        new BySegmentQueryRunner<T>(
-            segmentId, adapter.getDataInterval().getStart(),
-            factory.createRunner(adapter)
-        ),
+    return new FinalizeResultsQueryRunner<>(
+        new BySegmentQueryRunner<>(segmentId, adapter.getDataInterval().getStart(), factory.createRunner(adapter)),
         (QueryToolChest<T, Query<T>>) factory.getToolchest()
     );
   }
@@ -952,8 +924,8 @@ private List<QueryRunner<Row>> getQueryRunnerForSegment1()
     QueryableIndex index = groupByIndices.get(0);
     QueryRunner<Row> runner = makeQueryRunnerForSegment(
         groupByFactory,
-        index.toString(),
-        new QueryableIndexSegment(index.toString(), index)
+        SegmentId.dummy(index.toString()),
+        new QueryableIndexSegment(index, SegmentId.dummy(index.toString()))
     );
     runners.add(groupByFactory.getToolchest().preMergeQueryDecoration(runner));
     return runners;
@@ -965,8 +937,8 @@ private List<QueryRunner<Row>> getQueryRunnerForSegment2()
     QueryableIndex index2 = groupByIndices.get(1);
     QueryRunner<Row> tooSmallRunner = makeQueryRunnerForSegment(
         groupByFactory2,
-        index2.toString(),
-        new QueryableIndexSegment(index2.toString(), index2)
+        SegmentId.dummy(index2.toString()),
+        new QueryableIndexSegment(index2, SegmentId.dummy(index2.toString()))
     );
     runners.add(groupByFactory2.getToolchest().preMergeQueryDecoration(tooSmallRunner));
     return runners;
@@ -1000,17 +972,14 @@ public ByteBuffer get()
     }
   }
 
-  public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunnerForSegment(
+  private static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunnerForSegment(
       QueryRunnerFactory<T, QueryType> factory,
-      String segmentId,
+      SegmentId segmentId,
       Segment adapter
   )
   {
     return new FinalizeResultsQueryRunner<>(
-        new BySegmentQueryRunner<>(
-            segmentId, adapter.getDataInterval().getStart(),
-            factory.createRunner(adapter)
-        ),
+        new BySegmentQueryRunner<>(segmentId, adapter.getDataInterval().getStart(), factory.createRunner(adapter)),
         (QueryToolChest<T, Query<T>>) factory.getToolchest()
     );
   }

From 85319d092dbbd30fbb50a70369e1dc366c4b5957 Mon Sep 17 00:00:00 2001
From: Roman Leventov <leventov.ru@gmail.com>
Date: Mon, 19 Nov 2018 20:48:54 +0100
Subject: [PATCH 22/27] Add comments about why SegmentId and
 SegmentIdWithShardSpec are separate classes

---
 core/src/main/java/org/apache/druid/timeline/SegmentId.java  | 5 +++++
 .../realtime/appenderator/SegmentIdWithShardSpec.java        | 4 ++++
 2 files changed, 9 insertions(+)

diff --git a/core/src/main/java/org/apache/druid/timeline/SegmentId.java b/core/src/main/java/org/apache/druid/timeline/SegmentId.java
index f4a39729c1aa..c10c2fc3b6ea 100644
--- a/core/src/main/java/org/apache/druid/timeline/SegmentId.java
+++ b/core/src/main/java/org/apache/druid/timeline/SegmentId.java
@@ -55,6 +55,11 @@ public final class SegmentId implements Comparable<SegmentId>
    * Implementation note: this class must be optimized for resident memory footprint, because segment data consumes
    * a lot of heap memory on Druid Broker and Coordinator nodes.
    *
+   * This class is separate from org.apache.druid.segment.realtime.appenderator.SegmentIdWithShardSpec
+   * because in a lot of places segment ids are transmitted as "segment id strings" that don't contain enough
+   * information to deconstruct the ShardSpec. Also, even a single extra field is important for SegmentIds, because it
+   * adds to the memory footprint considerably.
+   *
    * API design note: "SegmentId" is chosen as the name for this class instead of more verbose "SegmentIdentifier" or
    * "DataSegmentIdentifier" because it's used very frequently and a long class name adds noticeable clutter. Variables
    * of SegmentId type are recommended to be named "segmentId" rather than "identifier" or "segmentIdentifier".
diff --git a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpec.java b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpec.java
index 4ea67023144a..58dad0d36448 100644
--- a/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpec.java
+++ b/server/src/main/java/org/apache/druid/segment/realtime/appenderator/SegmentIdWithShardSpec.java
@@ -30,6 +30,10 @@
 /**
  * {@link SegmentId} with additional {@link ShardSpec} info. {@link #equals}/{@link #hashCode} and {@link
  * #compareTo} don't consider that additinal info.
+ *
+ * This class is separate from {@link SegmentId} because in a lot of places segment ids are transmitted as "segment id
+ * strings" that don't contain enough information to deconstruct the {@link ShardSpec}. Also, even a single extra field
+ * in {@link SegmentId} is important, because it adds to the memory footprint considerably.
  */
 public final class SegmentIdWithShardSpec implements Comparable<SegmentIdWithShardSpec>
 {

From d7676b9b7ecd157dae76c361741242161dbd567d Mon Sep 17 00:00:00 2001
From: Roman Leventov <leventov.ru@gmail.com>
Date: Wed, 9 Jan 2019 18:01:54 +0700
Subject: [PATCH 23/27] Fix SystemSchemaTest

---
 .../org/apache/druid/timeline/SegmentId.java  |   8 +-
 .../druid/sql/calcite/schema/DruidSchema.java |  61 +++--
 .../sql/calcite/schema/SystemSchema.java      |  18 +-
 .../sql/calcite/schema/SystemSchemaTest.java  | 234 +++++++++---------
 4 files changed, 166 insertions(+), 155 deletions(-)

diff --git a/core/src/main/java/org/apache/druid/timeline/SegmentId.java b/core/src/main/java/org/apache/druid/timeline/SegmentId.java
index c10c2fc3b6ea..3e80716b7923 100644
--- a/core/src/main/java/org/apache/druid/timeline/SegmentId.java
+++ b/core/src/main/java/org/apache/druid/timeline/SegmentId.java
@@ -119,15 +119,15 @@ public static SegmentId tryParse(String dataSource, String segmentId)
    * Returns a (potentially empty) lazy iteration of all possible valid parsings of the given segment id string into
    * {@code SegmentId} objects.
    *
-   * Warning: this iterable repeats most of the parsing work on each iteration, so it should be iterated only once if
-   * possible.
+   * Warning: most of the parsing work is repeated each time {@link Iterable#iterator()} of this iterable is consumed,
+   * so it should be consumed only once if possible.
    */
   public static Iterable<SegmentId> iterateAllPossibleParsings(String segmentId)
   {
     List<String> splits = DELIMITER_SPLITTER.splitToList(segmentId);
     String probableDataSource = tryExtractMostProbableDataSource(segmentId);
-    // Iterate probable parsings first to allow for the users of iterateAllPossibleParsings() to break from the
-    // iteration earlier with higher probability.
+    // Iterate parsings with the most probably data source first to allow the users of iterateAllPossibleParsings() to
+    // break from the iteration earlier with higher probability.
     if (probableDataSource != null) {
       List<SegmentId> probableParsings = iteratePossibleParsingsWithDataSource(probableDataSource, segmentId);
       Iterable<SegmentId> otherPossibleParsings = () -> IntStream
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
index fe04a0c9095e..343aacc8a67f 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
@@ -82,7 +82,8 @@ public class DruidSchema extends AbstractSchema
 {
   // Newest segments first, so they override older ones.
   private static final Comparator<DataSegment> SEGMENT_ORDER = Comparator
-      .comparing((DataSegment segment) -> segment.getInterval().getStart()).reversed()
+      .comparing((DataSegment segment) -> segment.getInterval().getStart())
+      .reversed()
       .thenComparing(Function.identity());
 
   public static final String NAME = "druid";
@@ -106,6 +107,7 @@ public class DruidSchema extends AbstractSchema
   // Use TreeMap for segments so they are merged in deterministic order, from older to newer.
   // This data structure need to be accessed in a thread-safe way since SystemSchema accesses it
   private final Map<String, TreeMap<DataSegment, SegmentMetadataHolder>> segmentMetadataInfo = new HashMap<>();
+  private int totalSegments = 0;
 
   // All mutable segments.
   private final Set<DataSegment> mutableSegments = new TreeSet<>(SEGMENT_ORDER);
@@ -336,12 +338,11 @@ private void addSegment(final DruidServerMetadata server, final DataSegment segm
   {
     synchronized (lock) {
       final Map<DataSegment, SegmentMetadataHolder> knownSegments = segmentMetadataInfo.get(segment.getDataSource());
-      if (knownSegments == null || !knownSegments.containsKey(segment)) {
+      SegmentMetadataHolder holder = knownSegments != null ? knownSegments.get(segment) : null;
+      if (holder == null) {
         // segmentReplicatable is used to determine if segments are served by realtime servers or not
         final long isRealtime = server.segmentReplicatable() ? 0 : 1;
-        final SegmentMetadataHolder holder = SegmentMetadataHolder
-            .builder(segment.getId(), 0, 1, isRealtime, 1)
-            .build();
+        holder = SegmentMetadataHolder.builder(segment.getId(), 0, 1, isRealtime, 1).build();
         // Unknown segment.
         setSegmentSignature(segment, holder);
         segmentsNeedingRefresh.add(segment);
@@ -352,20 +353,17 @@ private void addSegment(final DruidServerMetadata server, final DataSegment segm
           log.debug("Added new immutable segment[%s].", segment.getId());
         }
       } else {
-        if (knownSegments.containsKey(segment)) {
-          final SegmentMetadataHolder holder = knownSegments.get(segment);
-          final SegmentMetadataHolder holderWithNumReplicas = SegmentMetadataHolder
-              .builder(
-                  holder.getSegmentId(),
-                  holder.isPublished(),
-                  holder.isAvailable(),
-                  holder.isRealtime(),
-                  holder.getNumReplicas()
-              )
-              .withNumReplicas(holder.getNumReplicas() + 1)
-              .build();
-          knownSegments.put(segment, holderWithNumReplicas);
-        }
+        final SegmentMetadataHolder holderWithNumReplicas = SegmentMetadataHolder
+            .builder(
+                holder.getSegmentId(),
+                holder.isPublished(),
+                holder.isAvailable(),
+                holder.isRealtime(),
+                holder.getNumReplicas()
+            )
+            .withNumReplicas(holder.getNumReplicas() + 1)
+            .build();
+        knownSegments.put(segment, holderWithNumReplicas);
         if (server.segmentReplicatable()) {
           // If a segment shows up on a replicatable (historical) server at any point, then it must be immutable,
           // even if it's also available on non-replicatable (realtime) servers.
@@ -390,8 +388,11 @@ private void removeSegment(final DataSegment segment)
       segmentsNeedingRefresh.remove(segment);
       mutableSegments.remove(segment);
 
-      final Map<DataSegment, SegmentMetadataHolder> dataSourceSegments = segmentMetadataInfo.get(segment.getDataSource());
-      dataSourceSegments.remove(segment);
+      final Map<DataSegment, SegmentMetadataHolder> dataSourceSegments =
+          segmentMetadataInfo.get(segment.getDataSource());
+      if (dataSourceSegments.remove(segment) != null) {
+        totalSegments--;
+      }
 
       if (dataSourceSegments.isEmpty()) {
         segmentMetadataInfo.remove(segment.getDataSource());
@@ -461,7 +462,8 @@ private Set<DataSegment> refreshSegmentsForDataSource(final String dataSource, f
           synchronized (lock) {
             final RowSignature rowSignature = analysisToRowSignature(analysis);
             log.debug("Segment[%s] has signature[%s].", segment.getId(), rowSignature);
-            final Map<DataSegment, SegmentMetadataHolder> dataSourceSegments = segmentMetadataInfo.get(segment.getDataSource());
+            final Map<DataSegment, SegmentMetadataHolder> dataSourceSegments =
+                segmentMetadataInfo.get(segment.getDataSource());
             SegmentMetadataHolder holder = dataSourceSegments.get(segment);
             SegmentMetadataHolder updatedHolder = SegmentMetadataHolder
                 .builder(
@@ -501,15 +503,20 @@ private Set<DataSegment> refreshSegmentsForDataSource(final String dataSource, f
   private void setSegmentSignature(final DataSegment segment, final SegmentMetadataHolder segmentMetadataHolder)
   {
     synchronized (lock) {
-      segmentMetadataInfo.computeIfAbsent(segment.getDataSource(), x -> new TreeMap<>(SEGMENT_ORDER))
-                         .put(segment, segmentMetadataHolder);
+      TreeMap<DataSegment, SegmentMetadataHolder> dataSourceSegments = segmentMetadataInfo.computeIfAbsent(
+          segment.getDataSource(),
+          x -> new TreeMap<>(SEGMENT_ORDER)
+      );
+      if (dataSourceSegments.put(segment, segmentMetadataHolder) == null) {
+        totalSegments++;
+      }
     }
   }
 
   private DruidTable buildDruidTable(final String dataSource)
   {
     synchronized (lock) {
-      final TreeMap<DataSegment, SegmentMetadataHolder> segmentMap = segmentMetadataInfo.get(dataSource);
+      final Map<DataSegment, SegmentMetadataHolder> segmentMap = segmentMetadataInfo.get(dataSource);
       final Map<String, ValueType> columnTypes = new TreeMap<>();
 
       if (segmentMap != null) {
@@ -595,4 +602,8 @@ public Map<DataSegment, SegmentMetadataHolder> getSegmentMetadata()
     }
     return segmentMetadata;
   }
+
+  int getTotalSegments() {
+    return totalSegments;
+  }
 }
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/SystemSchema.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/SystemSchema.java
index 8337924da8d8..1e9668c214dd 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/SystemSchema.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/SystemSchema.java
@@ -28,6 +28,7 @@
 import com.google.common.collect.FluentIterable;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
 import com.google.common.net.HostAndPort;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.inject.Inject;
@@ -82,7 +83,6 @@
 import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 public class SystemSchema extends AbstractSchema
 {
@@ -223,15 +223,13 @@ public Enumerable<Object[]> scan(DataContext root)
           availableSegmentMetadata.entrySet().iterator();
 
       // in memory map to store segment data from available segments
-      final Map<SegmentId, PartialSegmentData> partialSegmentDataMap = availableSegmentMetadata
-          .values()
-          .stream()
-          .collect(
-              Collectors.toMap(
-                  SegmentMetadataHolder::getSegmentId,
-                  h -> new PartialSegmentData(h.isAvailable(), h.isRealtime(), h.getNumReplicas(), h.getNumRows())
-              )
-          );
+      final Map<SegmentId, PartialSegmentData> partialSegmentDataMap =
+          Maps.newHashMapWithExpectedSize(druidSchema.getTotalSegments());
+      for (SegmentMetadataHolder h : availableSegmentMetadata.values()) {
+        PartialSegmentData partialSegmentData =
+            new PartialSegmentData(h.isAvailable(), h.isRealtime(), h.getNumReplicas(), h.getNumRows());
+        partialSegmentDataMap.put(h.getSegmentId(), partialSegmentData);
+      }
 
       //get published segments from coordinator
       final JsonParserIterator<DataSegment> metadataSegments = getMetadataSegments(
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
index 8ff632dde1eb..905dcd00b223 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
@@ -23,6 +23,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
 import com.google.common.util.concurrent.SettableFuture;
 import org.apache.calcite.DataContext;
 import org.apache.calcite.adapter.java.JavaTypeFactory;
@@ -482,143 +483,144 @@ public Object get(String name)
     };
 
     final List<Object[]> rows = segmentsTable.scan(dataContext).toList();
+    rows.sort((Object[] row1, Object[] row2) -> ((Comparable) row1[0]).compareTo(row2[0]));
 
     // total segments = 8
-    // segment wikipedia1, wikipedia2, wikipedia3 are published but unavailable
     // segments test1, test2  are published and available
     // segment test3 is served by historical but unpublished or unused
     // segments test4, test5 are not published but available (realtime segments)
+    // segment wikipedia1, wikipedia2, wikipedia3 are published but unavailable
 
     Assert.assertEquals(8, rows.size());
 
-    Object[] row0 = rows.get(0);
-    //segment 0 is published and unavailable, num_replicas is 0
-    Assert.assertEquals(
-        "wikipedia1_2018-08-07T23:00:00.000Z_2018-08-08T00:00:00.000Z_2018-08-07T23:00:00.059Z",
-        row0[0].toString()
+    verifyRow(
+        rows.get(0),
+        "test1_2010-01-01T00:00:00.000Z_2011-01-01T00:00:00.000Z_version1",
+        100L,
+        0L, //partition_num
+        1L, //num_replicas
+        3L, //numRows
+        1L, //is_published
+        1L, //is_available
+        0L //is_realtime
     );
-    Assert.assertEquals("wikipedia1", row0[1]);
-    Assert.assertEquals("2018-08-07T23:00:00.000Z", row0[2]);
-    Assert.assertEquals("2018-08-08T00:00:00.000Z", row0[3]);
-    Assert.assertEquals(47406L, row0[4]);
-    Assert.assertEquals("2018-08-07T23:00:00.059Z", row0[5]);
-    Assert.assertEquals(0L, row0[6]); //partition_num
-    Assert.assertEquals(0L, row0[7]); //num_replicas
-    Assert.assertEquals(0L, row0[8]); //numRows = 0
-    Assert.assertEquals(1L, row0[9]); //is_published
-    Assert.assertEquals(0L, row0[10]); //is_available
-    Assert.assertEquals(0L, row0[11]); //is_realtime
 
-    Object[] row1 = rows.get(1);
-    Assert.assertEquals(
-        "wikipedia2_2018-08-07T18:00:00.000Z_2018-08-07T19:00:00.000Z_2018-08-07T18:00:00.117Z",
-        row1[0].toString()
+    verifyRow(
+        rows.get(1),
+        "test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2",
+        100L,
+        0L, //partition_num
+        2L, //segment test2 is served by 2 servers, so num_replicas = 2
+        3L, //numRows
+        1L, //is_published
+        1L, //is_available
+        0L //is_realtime
     );
-    Assert.assertEquals("wikipedia2", row1[1]);
-    Assert.assertEquals("2018-08-07T18:00:00.000Z", row1[2]);
-    Assert.assertEquals("2018-08-07T19:00:00.000Z", row1[3]);
-    Assert.assertEquals(83846L, row1[4]);
-    Assert.assertEquals("2018-08-07T18:00:00.117Z", row1[5]);
-    Assert.assertEquals(0L, row1[6]); //partition_num
-    Assert.assertEquals(0L, row1[7]); //num_replicas
-    Assert.assertEquals(0L, row1[8]); //numRows = 0
-    Assert.assertEquals(1L, row1[9]); //is_published
-    Assert.assertEquals(0L, row1[10]); //is_available
-    Assert.assertEquals(0L, row1[11]); //is_realtime
 
+    //segment test3 is unpublished and has a NumberedShardSpec with partitionNum = 2
+    verifyRow(
+        rows.get(2),
+        "test3_2012-01-01T00:00:00.000Z_2013-01-01T00:00:00.000Z_version3_2",
+        100L,
+        2L, //partition_num
+        1L, //num_replicas
+        3L, //numRows
+        0L, //is_published
+        1L, //is_available
+        0L //is_realtime
+    );
 
-    Object[] row2 = rows.get(2);
-    Assert.assertEquals(
-        "wikipedia3_2018-08-07T23:00:00.000Z_2018-08-08T00:00:00.000Z_2018-08-07T23:00:00.059Z",
-        row2[0].toString()
+    verifyRow(
+        rows.get(3),
+        "test4_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version4",
+        100L,
+        0L, //partition_num
+        1L, //num_replicas
+        0L, //numRows = 3
+        0L, //is_published
+        1L, //is_available
+        1L //is_realtime
     );
-    Assert.assertEquals("wikipedia3", row2[1]);
-    Assert.assertEquals("2018-08-07T23:00:00.000Z", row2[2]);
-    Assert.assertEquals("2018-08-08T00:00:00.000Z", row2[3]);
-    Assert.assertEquals(53527L, row2[4]);
-    Assert.assertEquals("2018-08-07T23:00:00.059Z", row2[5]);
-    Assert.assertEquals(0L, row2[6]); //partition_num
-    Assert.assertEquals(0L, row2[7]); //num_replicas
-    Assert.assertEquals(0L, row2[8]); //numRows = 0
-    Assert.assertEquals(1L, row2[9]); //is_published
-    Assert.assertEquals(0L, row2[10]); //is_available
-    Assert.assertEquals(0L, row2[11]); //is_realtime
 
-    Object[] row3 = rows.get(3);
-    Assert.assertEquals("test1_2010-01-01T00:00:00.000Z_2011-01-01T00:00:00.000Z_version1", row3[0].toString());
-    Assert.assertEquals("test1", row3[1]);
-    Assert.assertEquals("2010-01-01T00:00:00.000Z", row3[2]);
-    Assert.assertEquals("2011-01-01T00:00:00.000Z", row3[3]);
-    Assert.assertEquals(100L, row3[4]);
-    Assert.assertEquals("version1", row3[5]);
-    Assert.assertEquals(0L, row3[6]); //partition_num
-    Assert.assertEquals(1L, row3[7]); //num_replicas
-    Assert.assertEquals(3L, row3[8]); //numRows = 3
-    Assert.assertEquals(1L, row3[9]); //is_published
-    Assert.assertEquals(1L, row3[10]); //is_available
-    Assert.assertEquals(0L, row3[11]); //is_realtime
+    verifyRow(
+        rows.get(4),
+        "test5_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version5",
+        100L,
+        0L, //partition_num
+        1L, //num_replicas
+        0L, //numRows
+        0L, //is_published
+        1L, //is_available
+        1L //is_realtime
+    );
 
-    Object[] row4 = rows.get(4);
-    Assert.assertEquals("test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2", row4[0].toString());
-    Assert.assertEquals("test2", row4[1]);
-    Assert.assertEquals("2011-01-01T00:00:00.000Z", row4[2]);
-    Assert.assertEquals("2012-01-01T00:00:00.000Z", row4[3]);
-    Assert.assertEquals(100L, row4[4]);
-    Assert.assertEquals("version2", row4[5]);
-    Assert.assertEquals(0L, row4[6]); //partition_num
-    Assert.assertEquals(2L, row4[7]); //segment test2 is served by 2 servers, so num_replicas=2
-    Assert.assertEquals(3L, row4[8]); //numRows = 3
-    Assert.assertEquals(1L, row4[9]); //is_published
-    Assert.assertEquals(1L, row4[10]); //is_available
-    Assert.assertEquals(0L, row4[11]); //is_realtime
-
-    Object[] row5 = rows.get(5);
-    //segment test3 is unpublished and has a NumberedShardSpec with partitionNum = 2
-    Assert.assertEquals("test3_2012-01-01T00:00:00.000Z_2013-01-01T00:00:00.000Z_version3_2", row5[0].toString());
-    Assert.assertEquals("test3", row5[1]);
-    Assert.assertEquals("2012-01-01T00:00:00.000Z", row5[2]);
-    Assert.assertEquals("2013-01-01T00:00:00.000Z", row5[3]);
-    Assert.assertEquals(100L, row5[4]);
-    Assert.assertEquals("version3", row5[5]);
-    Assert.assertEquals(2L, row5[6]); //partition_num = 2
-    Assert.assertEquals(1L, row5[7]); //num_replicas
-    Assert.assertEquals(3L, row5[8]); //numRows = 3
-    Assert.assertEquals(0L, row5[9]); //is_published
-    Assert.assertEquals(1L, row5[10]); //is_available
-    Assert.assertEquals(0L, row5[11]); //is_realtime
-
-    Object[] row6 = rows.get(6);
-    Assert.assertEquals("test5_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version5", row6[0].toString());
-    Assert.assertEquals("test5", row6[1]);
-    Assert.assertEquals("2017-01-01T00:00:00.000Z", row6[2]);
-    Assert.assertEquals("2018-01-01T00:00:00.000Z", row6[3]);
-    Assert.assertEquals(100L, row6[4]);
-    Assert.assertEquals("version5", row6[5]);
-    Assert.assertEquals(0L, row6[6]); //partition_num
-    Assert.assertEquals(1L, row6[7]); //num_replicas
-    Assert.assertEquals(0L, row6[8]); //numRows = 0
-    Assert.assertEquals(0L, row6[9]); //is_published
-    Assert.assertEquals(1L, row6[10]); //is_available
-    Assert.assertEquals(1L, row6[11]); //is_realtime
-
-    Object[] row7 = rows.get(7);
-    Assert.assertEquals("test4_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version4", row7[0].toString());
-    Assert.assertEquals("test4", row7[1]);
-    Assert.assertEquals("2017-01-01T00:00:00.000Z", row7[2]);
-    Assert.assertEquals("2018-01-01T00:00:00.000Z", row7[3]);
-    Assert.assertEquals(100L, row7[4]);
-    Assert.assertEquals("version4", row7[5]);
-    Assert.assertEquals(0L, row7[6]); //partition_num
-    Assert.assertEquals(1L, row7[7]); //num_replicas
-    Assert.assertEquals(0L, row7[8]); //numRows
-    Assert.assertEquals(0L, row7[9]); //is_published
-    Assert.assertEquals(1L, row7[10]); //is_available
-    Assert.assertEquals(1L, row7[11]); //is_realtime
+    // wikipedia segments are published and unavailable, num_replicas is 0
+    verifyRow(
+        rows.get(5),
+        "wikipedia1_2018-08-07T23:00:00.000Z_2018-08-08T00:00:00.000Z_2018-08-07T23:00:00.059Z",
+        47406L,
+        0L, //partition_num
+        0L, //num_replicas
+        0L, //numRows
+        1L, //is_published
+        0L, //is_available
+        0L //is_realtime
+    );
+
+    verifyRow(
+        rows.get(6),
+        "wikipedia2_2018-08-07T18:00:00.000Z_2018-08-07T19:00:00.000Z_2018-08-07T18:00:00.117Z",
+        83846L,
+        0L, //partition_num
+        0L, //num_replicas
+        0L, //numRows
+        1L, //is_published
+        0L, //is_available
+        0L //is_realtime
+    );
+
+    verifyRow(
+        rows.get(7),
+        "wikipedia3_2018-08-07T23:00:00.000Z_2018-08-08T00:00:00.000Z_2018-08-07T23:00:00.059Z",
+        53527L,
+        0L, //partition_num
+        0L, //num_replicas
+        0L, //numRows
+        1L, //is_published
+        0L, //is_available
+        0L //is_realtime
+    );
 
     // Verify value types.
     verifyTypes(rows, SystemSchema.SEGMENTS_SIGNATURE);
   }
 
+  private void verifyRow(
+      Object[] row,
+      String segmentId,
+      long size,
+      long partitionNum,
+      long numReplicas,
+      long numRows,
+      long isPublished,
+      long isAvailable,
+      long isRealtime)
+  {
+    Assert.assertEquals(segmentId, row[0].toString());
+    SegmentId id = Iterables.get(SegmentId.iterateAllPossibleParsings(segmentId), 0);
+    Assert.assertEquals(id.getDataSource(), row[1]);
+    Assert.assertEquals(id.getIntervalStart().toString(), row[2]);
+    Assert.assertEquals(id.getIntervalEnd().toString(), row[3]);
+    Assert.assertEquals(size, row[4]);
+    Assert.assertEquals(id.getVersion(), row[5]);
+    Assert.assertEquals(partitionNum, row[6]);
+    Assert.assertEquals(numReplicas, row[7]);
+    Assert.assertEquals(numRows, row[8]);
+    Assert.assertEquals(isPublished, row[9]);
+    Assert.assertEquals(isAvailable, row[10]);
+    Assert.assertEquals(isRealtime, row[11]);
+  }
+
   @Test
   public void testServersTable()
   {

From d8db03fb0e6d731819e52224a1af27c9d32335a3 Mon Sep 17 00:00:00 2001
From: Roman Leventov <leventov.ru@gmail.com>
Date: Wed, 9 Jan 2019 18:58:21 +0700
Subject: [PATCH 24/27] Fix style

---
 .../java/org/apache/druid/sql/calcite/schema/DruidSchema.java  | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
index 343aacc8a67f..d1c0d9cae386 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/schema/DruidSchema.java
@@ -603,7 +603,8 @@ public Map<DataSegment, SegmentMetadataHolder> getSegmentMetadata()
     return segmentMetadata;
   }
 
-  int getTotalSegments() {
+  int getTotalSegments()
+  {
     return totalSegments;
   }
 }

From 22573afcfb030d9e3cefbc744eeae93811a0634d Mon Sep 17 00:00:00 2001
From: Roman Leventov <leventov.ru@gmail.com>
Date: Wed, 9 Jan 2019 19:38:56 +0700
Subject: [PATCH 25/27] Compare SegmentDescriptor with SegmentId in Javadoc and
 comments rather than with DataSegment

---
 .../java/org/apache/druid/query/SegmentDescriptor.java | 10 +++++++---
 .../java/org/apache/druid/timeline/DataSegment.java    |  4 ----
 .../main/java/org/apache/druid/timeline/SegmentId.java |  8 ++++++++
 3 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/core/src/main/java/org/apache/druid/query/SegmentDescriptor.java b/core/src/main/java/org/apache/druid/query/SegmentDescriptor.java
index 4a9e666718be..a59d72206eac 100644
--- a/core/src/main/java/org/apache/druid/query/SegmentDescriptor.java
+++ b/core/src/main/java/org/apache/druid/query/SegmentDescriptor.java
@@ -24,9 +24,13 @@
 import org.joda.time.Interval;
 
 /**
- * The difference between this class and {@link org.apache.druid.timeline.DataSegment} is that this class is a "light"
- * version of {@link org.apache.druid.timeline.DataSegment}, that only contains the interval, version, and partition
- * number. SegmentDescriptor is used when Brokers tell data servers which segments to include for a particular query.
+ * The difference between this class and {@link org.apache.druid.timeline.SegmentId} is that this class is a "light"
+ * version of {@link org.apache.druid.timeline.SegmentId}, that only contains the interval, version, and partition
+ * number. It's used where the data source, another essential part of {@link org.apache.druid.timeline.SegmentId}
+ * is determined by the context (e. g. in {@link org.apache.druid.client.CachingClusteredClient}, where
+ * SegmentDescriptor is used when Brokers tell data servers which segments to include for a particular query) and where
+ * having lean JSON representations is important, because it's actively transferred detween Druid nodes. It's also for
+ * this reason that the JSON field names of SegmentDescriptor are abbreviated.
  */
 public class SegmentDescriptor
 {
diff --git a/core/src/main/java/org/apache/druid/timeline/DataSegment.java b/core/src/main/java/org/apache/druid/timeline/DataSegment.java
index 6b3c3051647f..ee75ec122e70 100644
--- a/core/src/main/java/org/apache/druid/timeline/DataSegment.java
+++ b/core/src/main/java/org/apache/druid/timeline/DataSegment.java
@@ -61,10 +61,6 @@ public class DataSegment implements Comparable<DataSegment>
   /*
    * The difference between this class and org.apache.druid.segment.Segment is that this class contains the segment
    * metadata only, while org.apache.druid.segment.Segment represents the actual body of segment data, queryable.
-   *
-   * The difference between this class and org.apache.druid.query.SegmentDescriptor is that SegmentDescriptor is
-   * a "light" version of DataSegment that only contains the interval, version, and partition number. SegmentDescriptor
-   * is used when Brokers tell data servers which segments to include for a particular query.
    */
 
   /**
diff --git a/core/src/main/java/org/apache/druid/timeline/SegmentId.java b/core/src/main/java/org/apache/druid/timeline/SegmentId.java
index 3e80716b7923..99ee8970a32b 100644
--- a/core/src/main/java/org/apache/druid/timeline/SegmentId.java
+++ b/core/src/main/java/org/apache/druid/timeline/SegmentId.java
@@ -60,6 +60,14 @@ public final class SegmentId implements Comparable<SegmentId>
    * information to deconstruct the ShardSpec. Also, even a single extra field is important for SegmentIds, because it
    * adds to the memory footprint considerably.
    *
+   * The difference between this class and {@link org.apache.druid.query.SegmentDescriptor} is that the latter is
+   * a "light" version of SegmentId, that only contains the interval, version, and partition number. It's used where the
+   * data source, another essential part of SegmentId is determined by the context (e. g. in {@link
+   * org.apache.druid.client.CachingClusteredClient}, where SegmentDescriptor is used when Brokers tell data servers
+   * which segments to include for a particular query) and where having lean JSON representations is important, because
+   * it's actively transferred detween Druid nodes. It's also for this reason that the JSON field names of
+   * SegmentDescriptor are abbreviated.
+   *
    * API design note: "SegmentId" is chosen as the name for this class instead of more verbose "SegmentIdentifier" or
    * "DataSegmentIdentifier" because it's used very frequently and a long class name adds noticeable clutter. Variables
    * of SegmentId type are recommended to be named "segmentId" rather than "identifier" or "segmentIdentifier".

From 15624f589f1da25a5429b5de19bd251681c11223 Mon Sep 17 00:00:00 2001
From: Roman Leventov <leventov.ru@gmail.com>
Date: Thu, 10 Jan 2019 18:59:44 +0700
Subject: [PATCH 26/27] Remove a link, see
 https://youtrack.jetbrains.com/issue/IDEA-205164

---
 .../java/org/apache/druid/query/SegmentDescriptor.java    | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/org/apache/druid/query/SegmentDescriptor.java b/core/src/main/java/org/apache/druid/query/SegmentDescriptor.java
index a59d72206eac..4f362cef0af0 100644
--- a/core/src/main/java/org/apache/druid/query/SegmentDescriptor.java
+++ b/core/src/main/java/org/apache/druid/query/SegmentDescriptor.java
@@ -27,10 +27,10 @@
  * The difference between this class and {@link org.apache.druid.timeline.SegmentId} is that this class is a "light"
  * version of {@link org.apache.druid.timeline.SegmentId}, that only contains the interval, version, and partition
  * number. It's used where the data source, another essential part of {@link org.apache.druid.timeline.SegmentId}
- * is determined by the context (e. g. in {@link org.apache.druid.client.CachingClusteredClient}, where
- * SegmentDescriptor is used when Brokers tell data servers which segments to include for a particular query) and where
- * having lean JSON representations is important, because it's actively transferred detween Druid nodes. It's also for
- * this reason that the JSON field names of SegmentDescriptor are abbreviated.
+ * is determined by the context (e. g. in org.apache.druid.client.CachingClusteredClient, where SegmentDescriptor is
+ * used when Brokers tell data servers which segments to include for a particular query) and where having lean JSON
+ * representations is important, because it's actively transferred detween Druid nodes. It's also for this reason that
+ * the JSON field names of SegmentDescriptor are abbreviated.
  */
 public class SegmentDescriptor
 {

From d889962343f381329bd0c0cb0af81ea98e68e79d Mon Sep 17 00:00:00 2001
From: Roman Leventov <leventov.ru@gmail.com>
Date: Wed, 16 Jan 2019 17:50:49 +0700
Subject: [PATCH 27/27] Fix compilation

---
 .../MaterializedViewQueryQueryToolChestTest.java         | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewQueryQueryToolChestTest.java b/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewQueryQueryToolChestTest.java
index fae69e61db25..0c750c3f5179 100644
--- a/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewQueryQueryToolChestTest.java
+++ b/extensions-contrib/materialized-view-selection/src/test/java/org/apache/druid/query/materializedview/MaterializedViewQueryQueryToolChestTest.java
@@ -46,7 +46,7 @@ public void testMakePostComputeManipulatorFn()
     TimeseriesQuery realQuery = Druids.newTimeseriesQueryBuilder()
                                         .dataSource(QueryRunnerTestHelper.dataSource)
                                         .granularity(QueryRunnerTestHelper.dayGran)
-                                        .intervals(QueryRunnerTestHelper.fullOnInterval)
+                                        .intervals(QueryRunnerTestHelper.fullOnIntervalSpec)
                                         .aggregators(QueryRunnerTestHelper.rowsCount)
                                         .descending(true)
                                         .build();
@@ -77,9 +77,10 @@ public Object manipulate(AggregatorFactory factory, Object object)
 
 
 
-    Result<TimeseriesResultValue> result = new Result<>(DateTimes.nowUtc(), new TimeseriesResultValue(ImmutableMap.<String, Object>builder()
-                                                                                                      .put("dim1", "dimvalue1")
-                                                                                                      .build()));
+    Result<TimeseriesResultValue> result = new Result<>(
+        DateTimes.nowUtc(),
+        new TimeseriesResultValue(ImmutableMap.of("dim1", "dimvalue1"))
+    );
 
     Result<TimeseriesResultValue> postResult = (Result<TimeseriesResultValue>) postFn.apply(result);
     Map<String, Object> postResultMap = postResult.getValue().getBaseObject();