diff --git a/server/src/internalClusterTest/java/org/opensearch/index/mapper/StarTreeMapperIT.java b/server/src/internalClusterTest/java/org/opensearch/index/mapper/StarTreeMapperIT.java
index 0d69b762ab4f2..5840884f5422a 100644
--- a/server/src/internalClusterTest/java/org/opensearch/index/mapper/StarTreeMapperIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/index/mapper/StarTreeMapperIT.java
@@ -12,6 +12,7 @@
 import org.opensearch.action.index.IndexResponse;
 import org.opensearch.action.search.SearchResponse;
 import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.common.Rounding;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.common.unit.ByteSizeUnit;
@@ -22,9 +23,13 @@
 import org.opensearch.index.IndexService;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.compositeindex.CompositeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.DataCubeDateTimeUnit;
+import org.opensearch.index.compositeindex.datacube.DateDimension;
 import org.opensearch.index.compositeindex.datacube.MetricStat;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitAdapter;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitRounding;
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.search.SearchHit;
@@ -58,13 +63,10 @@ private static XContentBuilder createMinimalTestMapping(boolean invalidDim, bool
                 .startObject("startree-1")
                 .field("type", "star_tree")
                 .startObject("config")
-                .startArray("ordered_dimensions")
-                .startObject()
-                .field("name", "numeric_dv_1")
-                .endObject()
-                .startObject()
-                .field("name", "numeric_dv_2")
+                .startObject("date_dimension")
+                .field("name", "timestamp")
                 .endObject()
+                .startArray("ordered_dimensions")
                 .startObject()
                 .field("name", getDim(invalidDim, keywordDim))
                 .endObject()
@@ -85,11 +87,58 @@ private static XContentBuilder createMinimalTestMapping(boolean invalidDim, bool
                 .field("type", "integer")
                 .field("doc_values", true)
                 .endObject()
-                .startObject("numeric_dv_1")
+                .startObject("numeric")
                 .field("type", "integer")
+                .field("doc_values", false)
+                .endObject()
+                .startObject("keyword_dv")
+                .field("type", "keyword")
                 .field("doc_values", true)
                 .endObject()
-                .startObject("numeric_dv_2")
+                .startObject("keyword")
+                .field("type", "keyword")
+                .field("doc_values", false)
+                .endObject()
+                .endObject()
+                .endObject();
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    private static XContentBuilder createDateTestMapping(boolean duplicate) {
+        try {
+            return jsonBuilder().startObject()
+                .startObject("composite")
+                .startObject("startree-1")
+                .field("type", "star_tree")
+                .startObject("config")
+                .startObject("date_dimension")
+                .field("name", "timestamp")
+                .startArray("calendar_intervals")
+                .value("day")
+                .value("quarter-hour")
+                .value(duplicate ? "quarter-hour" : "half-hour")
+                .endArray()
+                .endObject()
+                .startArray("ordered_dimensions")
+                .startObject()
+                .field("name", "numeric_dv")
+                .endObject()
+                .endArray()
+                .startArray("metrics")
+                .startObject()
+                .field("name", "numeric_dv")
+                .endObject()
+                .endArray()
+                .endObject()
+                .endObject()
+                .endObject()
+                .startObject("properties")
+                .startObject("timestamp")
+                .field("type", "date")
+                .endObject()
+                .startObject("numeric_dv")
                 .field("type", "integer")
                 .field("doc_values", true)
                 .endObject()
@@ -119,10 +168,15 @@ private static XContentBuilder createMaxDimTestMapping() {
                 .startObject("startree-1")
                 .field("type", "star_tree")
                 .startObject("config")
-                .startArray("ordered_dimensions")
-                .startObject()
-                .field("name", "dim4")
+                .startObject("date_dimension")
+                .field("name", "timestamp")
+                .startArray("calendar_intervals")
+                .value("day")
+                .value("month")
+                .value("half-hour")
+                .endArray()
                 .endObject()
+                .startArray("ordered_dimensions")
                 .startObject()
                 .field("name", "dim2")
                 .endObject()
@@ -167,7 +221,7 @@ private static XContentBuilder createMaxDimTestMapping() {
         }
     }
 
-    private static XContentBuilder createTestMappingWithoutStarTree(boolean invalidDim, boolean invalidMetric, boolean keywordDim) {
+    private static XContentBuilder createTestMappingWithoutStarTree() {
         try {
             return jsonBuilder().startObject()
                 .startObject("properties")
@@ -204,10 +258,10 @@ private static XContentBuilder createUpdateTestMapping(boolean changeDim, boolea
                 .startObject(sameStarTree ? "startree-1" : "startree-2")
                 .field("type", "star_tree")
                 .startObject("config")
-                .startArray("ordered_dimensions")
-                .startObject()
-                .field("name", "numeric_dv1")
+                .startObject("date_dimension")
+                .field("name", "timestamp")
                 .endObject()
+                .startArray("ordered_dimensions")
                 .startObject()
                 .field("name", changeDim ? "numeric_new" : getDim(false, false))
                 .endObject()
@@ -228,10 +282,6 @@ private static XContentBuilder createUpdateTestMapping(boolean changeDim, boolea
                 .field("type", "integer")
                 .field("doc_values", true)
                 .endObject()
-                .startObject("numeric_dv1")
-                .field("type", "integer")
-                .field("doc_values", true)
-                .endObject()
                 .startObject("numeric")
                 .field("type", "integer")
                 .field("doc_values", false)
@@ -263,10 +313,10 @@ private XContentBuilder getMappingWithDuplicateFields(boolean isDuplicateDim, bo
                 .startObject("startree-1")
                 .field("type", "star_tree")
                 .startObject("config")
-                .startArray("ordered_dimensions")
-                .startObject()
-                .field("name", "numeric_dv2")
+                .startObject("date_dimension")
+                .field("name", "timestamp")
                 .endObject()
+                .startArray("ordered_dimensions")
                 .startObject()
                 .field("name", "numeric_dv")
                 .endObject()
@@ -293,10 +343,6 @@ private XContentBuilder getMappingWithDuplicateFields(boolean isDuplicateDim, bo
                 .field("type", "integer")
                 .field("doc_values", true)
                 .endObject()
-                .startObject("numeric_dv2")
-                .field("type", "integer")
-                .field("doc_values", true)
-                .endObject()
                 .startObject("numeric_dv1")
                 .field("type", "integer")
                 .field("doc_values", true)
@@ -341,8 +387,92 @@ public void testValidCompositeIndex() {
                 for (CompositeMappedFieldType ft : fts) {
                     assertTrue(ft instanceof StarTreeMapper.StarTreeFieldType);
                     StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) ft;
-                    assertEquals("numeric_dv_1", starTreeFieldType.getDimensions().get(0).getField());
-                    assertEquals("numeric_dv_2", starTreeFieldType.getDimensions().get(1).getField());
+                    assertEquals("timestamp", starTreeFieldType.getDimensions().get(0).getField());
+                    assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+                    DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+                    List<DateTimeUnitRounding> expectedTimeUnits = Arrays.asList(
+                        new DateTimeUnitAdapter(Rounding.DateTimeUnit.MINUTES_OF_HOUR),
+                        DataCubeDateTimeUnit.HALF_HOUR_OF_DAY
+                    );
+                    for (int i = 0; i < dateDim.getSortedCalendarIntervals().size(); i++) {
+                        assertEquals(expectedTimeUnits.get(i).shortName(), dateDim.getSortedCalendarIntervals().get(i).shortName());
+                    }
+                    assertEquals("numeric_dv", starTreeFieldType.getDimensions().get(1).getField());
+                    assertEquals("numeric_dv", starTreeFieldType.getMetrics().get(0).getField());
+                    List<MetricStat> expectedMetrics = Arrays.asList(MetricStat.VALUE_COUNT, MetricStat.SUM, MetricStat.AVG);
+                    assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+                    assertEquals(10000, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+                    assertEquals(
+                        StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP,
+                        starTreeFieldType.getStarTreeConfig().getBuildMode()
+                    );
+                    assertEquals(Collections.emptySet(), starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims());
+                }
+            }
+        }
+    }
+
+    public void testValidCompositeIndexWithDates() {
+        prepareCreate(TEST_INDEX).setMapping(createDateTestMapping(false)).setSettings(settings).get();
+        Iterable<IndicesService> dataNodeInstances = internalCluster().getDataNodeInstances(IndicesService.class);
+        for (IndicesService service : dataNodeInstances) {
+            final Index index = resolveIndex("test");
+            if (service.hasIndex(index)) {
+                IndexService indexService = service.indexService(index);
+                Set<CompositeMappedFieldType> fts = indexService.mapperService().getCompositeFieldTypes();
+
+                for (CompositeMappedFieldType ft : fts) {
+                    assertTrue(ft instanceof StarTreeMapper.StarTreeFieldType);
+                    StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) ft;
+                    assertEquals("timestamp", starTreeFieldType.getDimensions().get(0).getField());
+                    assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+                    DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+                    List<DateTimeUnitRounding> expectedTimeUnits = Arrays.asList(
+                        DataCubeDateTimeUnit.QUARTER_HOUR_OF_DAY,
+                        DataCubeDateTimeUnit.HALF_HOUR_OF_DAY,
+                        new DateTimeUnitAdapter(Rounding.DateTimeUnit.DAY_OF_MONTH)
+                    );
+                    for (int i = 0; i < dateDim.getIntervals().size(); i++) {
+                        assertEquals(expectedTimeUnits.get(i).shortName(), dateDim.getSortedCalendarIntervals().get(i).shortName());
+                    }
+                    assertEquals("numeric_dv", starTreeFieldType.getDimensions().get(1).getField());
+                    assertEquals("numeric_dv", starTreeFieldType.getMetrics().get(0).getField());
+                    List<MetricStat> expectedMetrics = Arrays.asList(MetricStat.VALUE_COUNT, MetricStat.SUM, MetricStat.AVG);
+                    assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+                    assertEquals(10000, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+                    assertEquals(
+                        StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP,
+                        starTreeFieldType.getStarTreeConfig().getBuildMode()
+                    );
+                    assertEquals(Collections.emptySet(), starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims());
+                }
+            }
+        }
+    }
+
+    public void testValidCompositeIndexWithDuplicateDates() {
+        prepareCreate(TEST_INDEX).setMapping(createDateTestMapping(true)).setSettings(settings).get();
+        Iterable<IndicesService> dataNodeInstances = internalCluster().getDataNodeInstances(IndicesService.class);
+        for (IndicesService service : dataNodeInstances) {
+            final Index index = resolveIndex("test");
+            if (service.hasIndex(index)) {
+                IndexService indexService = service.indexService(index);
+                Set<CompositeMappedFieldType> fts = indexService.mapperService().getCompositeFieldTypes();
+
+                for (CompositeMappedFieldType ft : fts) {
+                    assertTrue(ft instanceof StarTreeMapper.StarTreeFieldType);
+                    StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) ft;
+                    assertEquals("timestamp", starTreeFieldType.getDimensions().get(0).getField());
+                    assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+                    DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+                    List<DateTimeUnitRounding> expectedTimeUnits = Arrays.asList(
+                        DataCubeDateTimeUnit.QUARTER_HOUR_OF_DAY,
+                        new DateTimeUnitAdapter(Rounding.DateTimeUnit.DAY_OF_MONTH)
+                    );
+                    for (int i = 0; i < dateDim.getIntervals().size(); i++) {
+                        assertEquals(expectedTimeUnits.get(i).shortName(), dateDim.getSortedCalendarIntervals().get(i).shortName());
+                    }
+                    assertEquals("numeric_dv", starTreeFieldType.getDimensions().get(1).getField());
                     assertEquals(2, starTreeFieldType.getMetrics().size());
                     assertEquals("numeric_dv", starTreeFieldType.getMetrics().get(0).getField());
 
@@ -458,7 +588,7 @@ public void testUpdateIndexWithAdditionOfStarTree() {
     }
 
     public void testUpdateIndexWithNewerStarTree() {
-        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createTestMappingWithoutStarTree(false, false, false)).get();
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createTestMappingWithoutStarTree()).get();
 
         IllegalArgumentException ex = expectThrows(
             IllegalArgumentException.class,
@@ -502,8 +632,18 @@ public void testUpdateIndexWhenMappingIsSame() {
                 for (CompositeMappedFieldType ft : fts) {
                     assertTrue(ft instanceof StarTreeMapper.StarTreeFieldType);
                     StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) ft;
-                    assertEquals("numeric_dv_1", starTreeFieldType.getDimensions().get(0).getField());
-                    assertEquals("numeric_dv_2", starTreeFieldType.getDimensions().get(1).getField());
+                    assertEquals("timestamp", starTreeFieldType.getDimensions().get(0).getField());
+                    assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+                    DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+                    List<DateTimeUnitRounding> expectedTimeUnits = Arrays.asList(
+                        new DateTimeUnitAdapter(Rounding.DateTimeUnit.MINUTES_OF_HOUR),
+                        DataCubeDateTimeUnit.HALF_HOUR_OF_DAY
+                    );
+                    for (int i = 0; i < expectedTimeUnits.size(); i++) {
+                        assertEquals(expectedTimeUnits.get(i).shortName(), dateDim.getIntervals().get(i).shortName());
+                    }
+
+                    assertEquals("numeric_dv", starTreeFieldType.getDimensions().get(1).getField());
                     assertEquals("numeric_dv", starTreeFieldType.getMetrics().get(0).getField());
 
                     // Assert default metrics
@@ -536,6 +676,7 @@ public void testMaxDimsCompositeIndex() {
             MapperParsingException.class,
             () -> prepareCreate(TEST_INDEX).setSettings(settings)
                 .setMapping(createMaxDimTestMapping())
+                // Date dimension is considered as one dimension regardless of number of actual calendar intervals
                 .setSettings(
                     Settings.builder()
                         .put(StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_SETTING.getKey(), 2)
@@ -569,6 +710,24 @@ public void testMaxMetricsCompositeIndex() {
         );
     }
 
+    public void testMaxCalendarIntervalsCompositeIndex() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> prepareCreate(TEST_INDEX).setMapping(createMaxDimTestMapping())
+                .setSettings(
+                    Settings.builder()
+                        .put(StarTreeIndexSettings.STAR_TREE_MAX_DATE_INTERVALS_SETTING.getKey(), 1)
+                        .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+                        .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(512, ByteSizeUnit.MB))
+                )
+                .get()
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: At most [1] calendar intervals are allowed in dimension [timestamp]",
+            ex.getMessage()
+        );
+    }
+
     public void testUnsupportedDim() {
         MapperParsingException ex = expectThrows(
             MapperParsingException.class,
diff --git a/server/src/main/java/org/opensearch/common/Rounding.java b/server/src/main/java/org/opensearch/common/Rounding.java
index b6509a57761b1..83411dea9dad3 100644
--- a/server/src/main/java/org/opensearch/common/Rounding.java
+++ b/server/src/main/java/org/opensearch/common/Rounding.java
@@ -96,7 +96,7 @@ public enum DateTimeUnit {
         WEEK_OF_WEEKYEAR((byte) 1, "week", IsoFields.WEEK_OF_WEEK_BASED_YEAR, true, TimeUnit.DAYS.toMillis(7)) {
             private final long extraLocalOffsetLookup = TimeUnit.DAYS.toMillis(7);
 
-            long roundFloor(long utcMillis) {
+            public long roundFloor(long utcMillis) {
                 return DateUtils.roundWeekOfWeekYear(utcMillis);
             }
 
@@ -108,7 +108,7 @@ long extraLocalOffsetLookup() {
         YEAR_OF_CENTURY((byte) 2, "year", ChronoField.YEAR_OF_ERA, false, 12) {
             private final long extraLocalOffsetLookup = TimeUnit.DAYS.toMillis(366);
 
-            long roundFloor(long utcMillis) {
+            public long roundFloor(long utcMillis) {
                 return DateUtils.roundYear(utcMillis);
             }
 
@@ -119,7 +119,7 @@ long extraLocalOffsetLookup() {
         QUARTER_OF_YEAR((byte) 3, "quarter", IsoFields.QUARTER_OF_YEAR, false, 3) {
             private final long extraLocalOffsetLookup = TimeUnit.DAYS.toMillis(92);
 
-            long roundFloor(long utcMillis) {
+            public long roundFloor(long utcMillis) {
                 return DateUtils.roundQuarterOfYear(utcMillis);
             }
 
@@ -130,7 +130,7 @@ long extraLocalOffsetLookup() {
         MONTH_OF_YEAR((byte) 4, "month", ChronoField.MONTH_OF_YEAR, false, 1) {
             private final long extraLocalOffsetLookup = TimeUnit.DAYS.toMillis(31);
 
-            long roundFloor(long utcMillis) {
+            public long roundFloor(long utcMillis) {
                 return DateUtils.roundMonthOfYear(utcMillis);
             }
 
@@ -139,7 +139,7 @@ long extraLocalOffsetLookup() {
             }
         },
         DAY_OF_MONTH((byte) 5, "day", ChronoField.DAY_OF_MONTH, true, ChronoField.DAY_OF_MONTH.getBaseUnit().getDuration().toMillis()) {
-            long roundFloor(long utcMillis) {
+            public long roundFloor(long utcMillis) {
                 return DateUtils.roundFloor(utcMillis, this.ratio);
             }
 
@@ -148,7 +148,7 @@ long extraLocalOffsetLookup() {
             }
         },
         HOUR_OF_DAY((byte) 6, "hour", ChronoField.HOUR_OF_DAY, true, ChronoField.HOUR_OF_DAY.getBaseUnit().getDuration().toMillis()) {
-            long roundFloor(long utcMillis) {
+            public long roundFloor(long utcMillis) {
                 return DateUtils.roundFloor(utcMillis, ratio);
             }
 
@@ -163,7 +163,7 @@ long extraLocalOffsetLookup() {
             true,
             ChronoField.MINUTE_OF_HOUR.getBaseUnit().getDuration().toMillis()
         ) {
-            long roundFloor(long utcMillis) {
+            public long roundFloor(long utcMillis) {
                 return DateUtils.roundFloor(utcMillis, ratio);
             }
 
@@ -178,7 +178,7 @@ long extraLocalOffsetLookup() {
             true,
             ChronoField.SECOND_OF_MINUTE.getBaseUnit().getDuration().toMillis()
         ) {
-            long roundFloor(long utcMillis) {
+            public long roundFloor(long utcMillis) {
                 return DateUtils.roundFloor(utcMillis, ratio);
             }
 
@@ -211,7 +211,7 @@ long extraLocalOffsetLookup() {
          * @param utcMillis the milliseconds since the epoch
          * @return          the rounded down milliseconds since the epoch
          */
-        abstract long roundFloor(long utcMillis);
+        public abstract long roundFloor(long utcMillis);
 
         /**
          * When looking up {@link LocalTimeOffset} go this many milliseconds
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/DataCubeDateTimeUnit.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DataCubeDateTimeUnit.java
new file mode 100644
index 0000000000000..56b704103dcae
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DataCubeDateTimeUnit.java
@@ -0,0 +1,77 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitRounding;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static java.util.Collections.unmodifiableMap;
+
+/**
+ * Enum representing the extended date time units supported for star tree index as part of index mapping.
+ * The enum values are:
+ * <ul>
+ *     <li>HALF_HOUR_OF_DAY: Represents half hour of day rounding</li>
+ *     <li>QUARTER_HOUR_OF_DAY: Represents quarter hour of day rounding</li>
+ * </ul>
+ * <p>
+ * The enum also provides a static map of date field units to their corresponding ExtendedDateTimeUnit instances.
+ *
+ * @see org.opensearch.common.Rounding.DateTimeUnit for more information on the dateTimeUnit enum and rounding logic.
+ *
+ * @opensearch.experimental
+ */
+public enum DataCubeDateTimeUnit implements DateTimeUnitRounding {
+    HALF_HOUR_OF_DAY("half-hour") {
+        @Override
+        public long roundFloor(long utcMillis) {
+            return utcMillis - (utcMillis % TimeUnit.MINUTES.toMillis(30));
+        }
+    },
+    QUARTER_HOUR_OF_DAY("quarter-hour") {
+        @Override
+        public long roundFloor(long utcMillis) {
+            return utcMillis - (utcMillis % TimeUnit.MINUTES.toMillis(15));
+        }
+    };
+
+    public static final Map<String, DataCubeDateTimeUnit> DATE_FIELD_UNITS;
+    static {
+        Map<String, DataCubeDateTimeUnit> dateFieldUnits = new HashMap<>();
+        dateFieldUnits.put("30m", DataCubeDateTimeUnit.HALF_HOUR_OF_DAY);
+        dateFieldUnits.put("half-hour", DataCubeDateTimeUnit.HALF_HOUR_OF_DAY);
+        dateFieldUnits.put("15m", DataCubeDateTimeUnit.QUARTER_HOUR_OF_DAY);
+        dateFieldUnits.put("quarter-hour", DataCubeDateTimeUnit.QUARTER_HOUR_OF_DAY);
+        DATE_FIELD_UNITS = unmodifiableMap(dateFieldUnits);
+    }
+
+    private final String shortName;
+
+    DataCubeDateTimeUnit(String shortName) {
+        this.shortName = shortName;
+    }
+
+    /**
+     * This rounds down the supplied milliseconds since the epoch down to the next unit. In order to retain performance this method
+     * should be as fast as possible and not try to convert dates to java-time objects if possible
+     *
+     * @param utcMillis the milliseconds since the epoch
+     * @return          the rounded down milliseconds since the epoch
+     */
+    @Override
+    public abstract long roundFloor(long utcMillis);
+
+    @Override
+    public String shortName() {
+        return shortName;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/DateDimension.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DateDimension.java
index 074016db2aed7..ee6d5b4680c73 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/DateDimension.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DateDimension.java
@@ -10,12 +10,21 @@
 
 import org.opensearch.common.Rounding;
 import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.time.DateUtils;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitRounding;
 import org.opensearch.index.mapper.CompositeDataCubeFieldType;
+import org.opensearch.index.mapper.DateFieldMapper;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 /**
  * Date dimension class
@@ -24,27 +33,78 @@
  */
 @ExperimentalApi
 public class DateDimension implements Dimension {
-    private final List<Rounding.DateTimeUnit> calendarIntervals;
+    private final List<DateTimeUnitRounding> calendarIntervals;
     public static final String CALENDAR_INTERVALS = "calendar_intervals";
     public static final String DATE = "date";
     private final String field;
+    private final List<DateTimeUnitRounding> sortedCalendarIntervals;
+    private final DateFieldMapper.Resolution resolution;
 
-    public DateDimension(String field, List<Rounding.DateTimeUnit> calendarIntervals) {
+    public DateDimension(String field, List<DateTimeUnitRounding> calendarIntervals, DateFieldMapper.Resolution resolution) {
         this.field = field;
         this.calendarIntervals = calendarIntervals;
+        // Sort from the lowest unit to the highest unit
+        this.sortedCalendarIntervals = getSortedDateTimeUnits(calendarIntervals);
+        if (resolution == null) {
+            this.resolution = DateFieldMapper.Resolution.MILLISECONDS;
+        } else {
+            this.resolution = resolution;
+        }
     }
 
-    public List<Rounding.DateTimeUnit> getIntervals() {
+    public List<DateTimeUnitRounding> getIntervals() {
         return calendarIntervals;
     }
 
+    public List<DateTimeUnitRounding> getSortedCalendarIntervals() {
+        return sortedCalendarIntervals;
+    }
+
+    /**
+     * Sets the dimension values in sorted order in the provided array starting from the given index.
+     *
+     * @param val   The value to be set
+     * @param dimSetter  Consumer which sets the dimensions
+     */
+    @Override
+    public void setDimensionValues(final Long val, final Consumer<Long> dimSetter) {
+        for (DateTimeUnitRounding dateTimeUnit : sortedCalendarIntervals) {
+            if (val == null) {
+                dimSetter.accept(null);
+            } else {
+                Long roundedValue = dateTimeUnit.roundFloor(storedDurationSinceEpoch(val));
+                dimSetter.accept(roundedValue);
+            }
+        }
+    }
+
+    /**
+     * Converts nanoseconds to milliseconds based on the resolution of the field
+     */
+    private long storedDurationSinceEpoch(long nanoSecondsSinceEpoch) {
+        if (resolution.equals(DateFieldMapper.Resolution.NANOSECONDS)) return DateUtils.toMilliSeconds(nanoSecondsSinceEpoch);
+        return nanoSecondsSinceEpoch;
+    }
+
+    /**
+     * Returns the list of fields that represent the dimension
+     */
+    @Override
+    public List<String> getSubDimensionNames() {
+        List<String> fields = new ArrayList<>(calendarIntervals.size());
+        for (DateTimeUnitRounding interval : sortedCalendarIntervals) {
+            fields.add(field + "_" + interval.shortName());
+        }
+        return fields;
+    }
+
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject();
+        builder.startObject("date_dimension");
         builder.field(CompositeDataCubeFieldType.NAME, this.getField());
         builder.field(CompositeDataCubeFieldType.TYPE, DATE);
         builder.startArray(CALENDAR_INTERVALS);
-        for (Rounding.DateTimeUnit interval : calendarIntervals) {
+        for (DateTimeUnitRounding interval : calendarIntervals) {
             builder.value(interval.shortName());
         }
         builder.endArray();
@@ -69,4 +129,44 @@ public int hashCode() {
     public String getField() {
         return field;
     }
+
+    @Override
+    public int getNumSubDimensions() {
+        return calendarIntervals.size();
+    }
+
+    /**
+     * DateTimeUnit Comparator which tracks dateTimeUnits in sorted order from second unit to year unit
+     */
+    public static class DateTimeUnitComparator implements Comparator<DateTimeUnitRounding> {
+        public static final Map<String, Integer> ORDERED_DATE_TIME_UNIT = new HashMap<>();
+
+        static {
+            ORDERED_DATE_TIME_UNIT.put(Rounding.DateTimeUnit.SECOND_OF_MINUTE.shortName(), 1);
+            ORDERED_DATE_TIME_UNIT.put(Rounding.DateTimeUnit.MINUTES_OF_HOUR.shortName(), 2);
+            ORDERED_DATE_TIME_UNIT.put(DataCubeDateTimeUnit.QUARTER_HOUR_OF_DAY.shortName(), 3);
+            ORDERED_DATE_TIME_UNIT.put(DataCubeDateTimeUnit.HALF_HOUR_OF_DAY.shortName(), 4);
+            ORDERED_DATE_TIME_UNIT.put(Rounding.DateTimeUnit.HOUR_OF_DAY.shortName(), 5);
+            ORDERED_DATE_TIME_UNIT.put(Rounding.DateTimeUnit.DAY_OF_MONTH.shortName(), 6);
+            ORDERED_DATE_TIME_UNIT.put(Rounding.DateTimeUnit.WEEK_OF_WEEKYEAR.shortName(), 7);
+            ORDERED_DATE_TIME_UNIT.put(Rounding.DateTimeUnit.MONTH_OF_YEAR.shortName(), 8);
+            ORDERED_DATE_TIME_UNIT.put(Rounding.DateTimeUnit.QUARTER_OF_YEAR.shortName(), 9);
+            ORDERED_DATE_TIME_UNIT.put(Rounding.DateTimeUnit.YEAR_OF_CENTURY.shortName(), 10);
+        }
+
+        @Override
+        public int compare(DateTimeUnitRounding unit1, DateTimeUnitRounding unit2) {
+            return Integer.compare(
+                ORDERED_DATE_TIME_UNIT.getOrDefault(unit1.shortName(), Integer.MAX_VALUE),
+                ORDERED_DATE_TIME_UNIT.getOrDefault(unit2.shortName(), Integer.MAX_VALUE)
+            );
+        }
+    }
+
+    /**
+     * Returns a sorted list of dateTimeUnits based on the DateTimeUnitComparator
+     */
+    public static List<DateTimeUnitRounding> getSortedDateTimeUnits(List<DateTimeUnitRounding> dateTimeUnits) {
+        return dateTimeUnits.stream().sorted(new DateTimeUnitComparator()).collect(Collectors.toList());
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/Dimension.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/Dimension.java
index 0151a474579be..cfa8d3a2a8164 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/Dimension.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/Dimension.java
@@ -11,6 +11,9 @@
 import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.core.xcontent.ToXContent;
 
+import java.util.List;
+import java.util.function.Consumer;
+
 /**
  * Base interface for data-cube dimensions
  *
@@ -18,5 +21,25 @@
  */
 @ExperimentalApi
 public interface Dimension extends ToXContent {
+
     String getField();
+
+    /**
+     * Returns the number of dimension values that gets added to star tree document
+     * as part of this dimension
+     */
+    int getNumSubDimensions();
+
+    /**
+     * Sets the dimension values with the consumer
+     *
+     * @param value   The value to be set
+     * @param dimSetter  Consumer which sets the dimensions
+     */
+    void setDimensionValues(final Long value, final Consumer<Long> dimSetter);
+
+    /**
+     * Returns the list of dimension fields that represent the dimension
+     */
+    List<String> getSubDimensionNames();
 }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionFactory.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionFactory.java
index 3c418c68fe8ad..7e72a3f0d9de6 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionFactory.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionFactory.java
@@ -8,16 +8,19 @@
 
 package org.opensearch.index.compositeindex.datacube;
 
-import org.opensearch.common.Rounding;
 import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.xcontent.support.XContentMapValues;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitRounding;
+import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.mapper.Mapper;
 
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import static org.opensearch.index.compositeindex.datacube.DateDimension.CALENDAR_INTERVALS;
@@ -70,13 +73,13 @@ private static DateDimension parseAndCreateDateDimension(
         Map<String, Object> dimensionMap,
         Mapper.TypeParser.ParserContext c
     ) {
-        List<Rounding.DateTimeUnit> calendarIntervals = new ArrayList<>();
+        Set<DateTimeUnitRounding> calendarIntervals;
         List<String> intervalStrings = XContentMapValues.extractRawValues(CALENDAR_INTERVALS, dimensionMap)
             .stream()
             .map(Object::toString)
             .collect(Collectors.toList());
         if (intervalStrings == null || intervalStrings.isEmpty()) {
-            calendarIntervals = StarTreeIndexSettings.DEFAULT_DATE_INTERVALS.get(c.getSettings());
+            calendarIntervals = new LinkedHashSet<>(StarTreeIndexSettings.DEFAULT_DATE_INTERVALS.get(c.getSettings()));
         } else {
             if (intervalStrings.size() > StarTreeIndexSettings.STAR_TREE_MAX_DATE_INTERVALS_SETTING.get(c.getSettings())) {
                 throw new IllegalArgumentException(
@@ -88,12 +91,17 @@ private static DateDimension parseAndCreateDateDimension(
                     )
                 );
             }
+            calendarIntervals = new LinkedHashSet<>();
             for (String interval : intervalStrings) {
                 calendarIntervals.add(StarTreeIndexSettings.getTimeUnit(interval));
             }
-            calendarIntervals = new ArrayList<>(calendarIntervals);
         }
         dimensionMap.remove(CALENDAR_INTERVALS);
-        return new DateDimension(name, calendarIntervals);
+        DateFieldMapper.Resolution resolution = null;
+        if (c != null && c.mapperService() != null && c.mapperService().fieldType(name) != null) {
+            resolution = ((DateFieldMapper.DateFieldType) c.mapperService().fieldType(name)).resolution();
+        }
+
+        return new DateDimension(name, new ArrayList<>(calendarIntervals), resolution);
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/NumericDimension.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/NumericDimension.java
index 9c25ef5b25503..acc14f5f05c68 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/NumericDimension.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/NumericDimension.java
@@ -13,7 +13,9 @@
 import org.opensearch.index.mapper.CompositeDataCubeFieldType;
 
 import java.io.IOException;
+import java.util.List;
 import java.util.Objects;
+import java.util.function.Consumer;
 
 /**
  * Composite index numeric dimension class
@@ -33,6 +35,21 @@ public String getField() {
         return field;
     }
 
+    @Override
+    public int getNumSubDimensions() {
+        return 1;
+    }
+
+    @Override
+    public void setDimensionValues(final Long val, final Consumer<Long> dimSetter) {
+        dimSetter.accept(val);
+    }
+
+    @Override
+    public List<String> getSubDimensionNames() {
+        return List.of(field);
+    }
+
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject();
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/ReadDimension.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/ReadDimension.java
index 4264ec87d2c74..be3667f10b6da 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/ReadDimension.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/ReadDimension.java
@@ -12,7 +12,9 @@
 import org.opensearch.index.mapper.CompositeDataCubeFieldType;
 
 import java.io.IOException;
+import java.util.List;
 import java.util.Objects;
+import java.util.function.Consumer;
 
 /**
  * Represents a dimension for reconstructing StarTreeField from file formats during searches and merges.
@@ -31,6 +33,21 @@ public String getField() {
         return field;
     }
 
+    @Override
+    public int getNumSubDimensions() {
+        return 1;
+    }
+
+    @Override
+    public void setDimensionValues(final Long val, final Consumer<Long> dimSetter) {
+        dimSetter.accept(val);
+    }
+
+    @Override
+    public List<String> getSubDimensionNames() {
+        return List.of(field);
+    }
+
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject();
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeField.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeField.java
index 922ddcbea4fe2..833bf63c04a18 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeField.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeField.java
@@ -11,10 +11,13 @@
 import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.compositeindex.datacube.DateDimension;
 import org.opensearch.index.compositeindex.datacube.Dimension;
 import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 
@@ -29,12 +32,24 @@ public class StarTreeField implements ToXContent {
     private final List<Dimension> dimensionsOrder;
     private final List<Metric> metrics;
     private final StarTreeFieldConfiguration starTreeConfig;
+    private final List<String> dimensionNames;
+    private final List<String> metricNames;
 
     public StarTreeField(String name, List<Dimension> dimensions, List<Metric> metrics, StarTreeFieldConfiguration starTreeConfig) {
         this.name = name;
         this.dimensionsOrder = dimensions;
         this.metrics = metrics;
         this.starTreeConfig = starTreeConfig;
+        dimensionNames = new ArrayList<>();
+        for (Dimension dimension : dimensions) {
+            dimensionNames.addAll(dimension.getSubDimensionNames());
+        }
+        metricNames = new ArrayList<>();
+        for (Metric metric : metrics) {
+            for (MetricStat metricStat : metric.getMetrics()) {
+                metricNames.add(metric.getField() + "_" + metricStat.name());
+            }
+        }
     }
 
     public String getName() {
@@ -45,6 +60,14 @@ public List<Dimension> getDimensionsOrder() {
         return dimensionsOrder;
     }
 
+    public List<String> getDimensionNames() {
+        return dimensionNames;
+    }
+
+    public List<String> getMetricNames() {
+        return metricNames;
+    }
+
     public List<Metric> getMetrics() {
         return metrics;
     }
@@ -57,13 +80,22 @@ public StarTreeFieldConfiguration getStarTreeConfig() {
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject();
         builder.field("name", name);
+        DateDimension dateDim = null;
         if (dimensionsOrder != null && !dimensionsOrder.isEmpty()) {
             builder.startArray("ordered_dimensions");
             for (Dimension dimension : dimensionsOrder) {
+                // Handle dateDimension for later
+                if (dimension instanceof DateDimension) {
+                    dateDim = (DateDimension) dimension;
+                    continue;
+                }
                 dimension.toXContent(builder, params);
             }
             builder.endArray();
         }
+        if (dateDim != null) {
+            dateDim.toXContent(builder, params);
+        }
         if (metrics != null && !metrics.isEmpty()) {
             builder.startArray("metrics");
             for (Metric metric : metrics) {
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeIndexSettings.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeIndexSettings.java
index e665831b83d93..72be8ac44cbbc 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeIndexSettings.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeIndexSettings.java
@@ -10,7 +10,10 @@
 
 import org.opensearch.common.Rounding;
 import org.opensearch.common.settings.Setting;
+import org.opensearch.index.compositeindex.datacube.DataCubeDateTimeUnit;
 import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitAdapter;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitRounding;
 import org.opensearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
 
 import java.util.Arrays;
@@ -97,9 +100,9 @@ public class StarTreeIndexSettings {
     /**
      * Default intervals for date dimension as part of star tree fields
      */
-    public static final Setting<List<Rounding.DateTimeUnit>> DEFAULT_DATE_INTERVALS = Setting.listSetting(
+    public static final Setting<List<DateTimeUnitRounding>> DEFAULT_DATE_INTERVALS = Setting.listSetting(
         "index.composite_index.star_tree.field.default.date_intervals",
-        Arrays.asList(Rounding.DateTimeUnit.MINUTES_OF_HOUR.shortName(), Rounding.DateTimeUnit.HOUR_OF_DAY.shortName()),
+        Arrays.asList(Rounding.DateTimeUnit.MINUTES_OF_HOUR.shortName(), DataCubeDateTimeUnit.HALF_HOUR_OF_DAY.shortName()),
         StarTreeIndexSettings::getTimeUnit,
         Setting.Property.IndexScope,
         Setting.Property.Final
@@ -116,11 +119,13 @@ public class StarTreeIndexSettings {
         Setting.Property.Final
     );
 
-    public static Rounding.DateTimeUnit getTimeUnit(String expression) {
-        if (!DateHistogramAggregationBuilder.DATE_FIELD_UNITS.containsKey(expression)) {
-            throw new IllegalArgumentException("unknown calendar intervals specified in star tree index mapping");
+    public static DateTimeUnitRounding getTimeUnit(String expression) {
+        if (DateHistogramAggregationBuilder.DATE_FIELD_UNITS.containsKey(expression)) {
+            return new DateTimeUnitAdapter(DateHistogramAggregationBuilder.DATE_FIELD_UNITS.get(expression));
+        } else if (DataCubeDateTimeUnit.DATE_FIELD_UNITS.containsKey(expression)) {
+            return DataCubeDateTimeUnit.DATE_FIELD_UNITS.get(expression);
         }
-        return DateHistogramAggregationBuilder.DATE_FIELD_UNITS.get(expression);
+        throw new IllegalArgumentException("unknown calendar intervals specified in star tree index mapping");
     }
 
     public static final Setting<Boolean> IS_COMPOSITE_INDEX_SETTING = Setting.boolSetting(
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractDocumentsFileManager.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractDocumentsFileManager.java
index 327fd26c00608..3f4e302e0a0f2 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractDocumentsFileManager.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractDocumentsFileManager.java
@@ -43,17 +43,20 @@ public abstract class AbstractDocumentsFileManager implements Closeable {
     protected final TrackingDirectoryWrapper tmpDirectory;
     protected final SegmentWriteState state;
     protected int docSizeInBytes = -1;
+    protected final int numDimensions;
 
     public AbstractDocumentsFileManager(
         SegmentWriteState state,
         StarTreeField starTreeField,
-        List<MetricAggregatorInfo> metricAggregatorInfos
+        List<MetricAggregatorInfo> metricAggregatorInfos,
+        int numDimensions
     ) {
         this.starTreeField = starTreeField;
         this.tmpDirectory = new TrackingDirectoryWrapper(state.directory);
         this.metricAggregatorInfos = metricAggregatorInfos;
         this.state = state;
         numMetrics = metricAggregatorInfos.size();
+        this.numDimensions = numDimensions;
     }
 
     private void setDocSizeInBytes(int numBytes) {
@@ -124,8 +127,7 @@ protected int writeMetrics(StarTreeDocument starTreeDocument, IndexOutput output
      * @throws IOException IOException in case of I/O errors
      */
     protected StarTreeDocument readStarTreeDocument(RandomAccessInput input, long offset, boolean isAggregatedDoc) throws IOException {
-        int dimSize = starTreeField.getDimensionsOrder().size();
-        Long[] dimensions = new Long[dimSize];
+        Long[] dimensions = new Long[numDimensions];
         long initialOffset = offset;
         offset = readDimensions(dimensions, input, offset);
 
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java
index 5e5814528fcd2..2d4938eeb45b3 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java
@@ -18,6 +18,7 @@
 import org.apache.lucene.index.SegmentWriteState;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.index.SortedNumericDocValuesWriterWrapper;
+import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.store.IndexOutput;
 import org.apache.lucene.util.Counter;
 import org.apache.lucene.util.NumericUtils;
@@ -52,6 +53,7 @@
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.SEGMENT_DOCS_COUNT;
 import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.ALL;
 import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeDimensionsDocValues;
 import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
@@ -82,7 +84,7 @@ public abstract class BaseStarTreeBuilder implements StarTreeBuilder {
     protected int totalSegmentDocs;
     protected int numStarTreeNodes;
     protected final int maxLeafDocuments;
-
+    List<Dimension> dimensionsSplitOrder = new ArrayList<>();
     protected final InMemoryTreeNode rootNode = getNewNode();
 
     protected final StarTreeField starTreeField;
@@ -112,9 +114,12 @@ protected BaseStarTreeBuilder(
 
         this.starTreeField = starTreeField;
         StarTreeFieldConfiguration starTreeFieldSpec = starTreeField.getStarTreeConfig();
-
-        List<Dimension> dimensionsSplitOrder = starTreeField.getDimensionsOrder();
-        this.numDimensions = dimensionsSplitOrder.size();
+        int numDims = 0;
+        for (Dimension dim : starTreeField.getDimensionsOrder()) {
+            numDims += dim.getNumSubDimensions();
+            dimensionsSplitOrder.add(dim);
+        }
+        this.numDimensions = numDims;
 
         this.skipStarNodeCreationForDimensions = new HashSet<>();
         this.totalSegmentDocs = writeState.segmentInfo.maxDoc();
@@ -122,9 +127,12 @@ protected BaseStarTreeBuilder(
 
         Set<String> skipStarNodeCreationForDimensions = starTreeFieldSpec.getSkipStarNodeCreationInDims();
 
-        for (int i = 0; i < numDimensions; i++) {
+        for (int i = 0; i < dimensionsSplitOrder.size(); i++) {
             if (skipStarNodeCreationForDimensions.contains(dimensionsSplitOrder.get(i).getField())) {
-                this.skipStarNodeCreationForDimensions.add(i);
+                // add the dimension indices
+                for (int dimIndex = 0; dimIndex < dimensionsSplitOrder.get(i).getNumSubDimensions(); dimIndex++) {
+                    this.skipStarNodeCreationForDimensions.add(i + dimIndex);
+                }
             }
         }
 
@@ -224,7 +232,7 @@ public void build(
         List<SequentialDocValuesIterator> metricReaders = getMetricReaders(writeState, fieldProducerMap);
         List<Dimension> dimensionsSplitOrder = starTreeField.getDimensionsOrder();
         SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[dimensionsSplitOrder.size()];
-        for (int i = 0; i < numDimensions; i++) {
+        for (int i = 0; i < dimensionReaders.length; i++) {
             String dimension = dimensionsSplitOrder.get(i).getField();
             FieldInfo dimensionFieldInfo = writeState.fieldInfos.fieldInfo(dimension);
             if (dimensionFieldInfo == null) {
@@ -313,19 +321,20 @@ private void createSortedDocValuesIndices(DocValuesConsumer docValuesConsumer, A
         throws IOException {
         List<SortedNumericDocValuesWriterWrapper> dimensionWriters = new ArrayList<>();
         List<SortedNumericDocValuesWriterWrapper> metricWriters = new ArrayList<>();
-        FieldInfo[] dimensionFieldInfoList = new FieldInfo[starTreeField.getDimensionsOrder().size()];
+        FieldInfo[] dimensionFieldInfoList = new FieldInfo[numDimensions];
         FieldInfo[] metricFieldInfoList = new FieldInfo[metricAggregatorInfos.size()];
-        for (int i = 0; i < dimensionFieldInfoList.length; i++) {
-            final FieldInfo fi = getFieldInfo(
-                fullyQualifiedFieldNameForStarTreeDimensionsDocValues(
-                    starTreeField.getName(),
-                    starTreeField.getDimensionsOrder().get(i).getField()
-                ),
-                DocValuesType.SORTED_NUMERIC,
-                fieldNumberAcrossStarTrees.getAndIncrement()
-            );
-            dimensionFieldInfoList[i] = fi;
-            dimensionWriters.add(new SortedNumericDocValuesWriterWrapper(fi, Counter.newCounter()));
+        int dimIndex = 0;
+        for (Dimension dim : dimensionsSplitOrder) {
+            for (String name : dim.getSubDimensionNames()) {
+                final FieldInfo fi = getFieldInfo(
+                    fullyQualifiedFieldNameForStarTreeDimensionsDocValues(starTreeField.getName(), name),
+                    DocValuesType.SORTED_NUMERIC,
+                    fieldNumberAcrossStarTrees.getAndIncrement()
+                );
+                dimensionFieldInfoList[dimIndex] = fi;
+                dimensionWriters.add(new SortedNumericDocValuesWriterWrapper(fi, Counter.newCounter()));
+                dimIndex++;
+            }
         }
         for (int i = 0; i < metricAggregatorInfos.size(); i++) {
 
@@ -371,7 +380,7 @@ private void createSortedDocValuesIndices(DocValuesConsumer docValuesConsumer, A
             }
         }
 
-        addStarTreeDocValueFields(docValuesConsumer, dimensionWriters, dimensionFieldInfoList, starTreeField.getDimensionsOrder().size());
+        addStarTreeDocValueFields(docValuesConsumer, dimensionWriters, dimensionFieldInfoList, numDimensions);
         addStarTreeDocValueFields(docValuesConsumer, metricWriters, metricFieldInfoList, metricAggregatorInfos.size());
     }
 
@@ -422,6 +431,36 @@ protected StarTreeDocument getStarTreeDocument(
         return new StarTreeDocument(dims, metrics);
     }
 
+    /**
+     * Sets dimensions / metric readers nnd numSegmentDocs
+     */
+    protected void setReadersAndNumSegmentDocs(
+        SequentialDocValuesIterator[] dimensionReaders,
+        List<SequentialDocValuesIterator> metricReaders,
+        AtomicInteger numSegmentDocs,
+        StarTreeValues starTreeValues
+    ) {
+        List<String> dimensionNames = starTreeValues.getStarTreeField().getDimensionNames();
+        for (int i = 0; i < numDimensions; i++) {
+            dimensionReaders[i] = new SequentialDocValuesIterator(starTreeValues.getDimensionValuesIterator(dimensionNames.get(i)));
+        }
+        // get doc id set iterators for metrics
+        for (Metric metric : starTreeValues.getStarTreeField().getMetrics()) {
+            for (MetricStat metricStat : metric.getBaseMetrics()) {
+                String metricFullName = fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                    starTreeValues.getStarTreeField().getName(),
+                    metric.getField(),
+                    metricStat.getTypeName()
+                );
+                metricReaders.add(new SequentialDocValuesIterator(starTreeValues.getMetricValuesIterator(metricFullName)));
+            }
+        }
+
+        numSegmentDocs.set(
+            Integer.parseInt(starTreeValues.getAttributes().getOrDefault(SEGMENT_DOCS_COUNT, String.valueOf(DocIdSetIterator.NO_MORE_DOCS)))
+        );
+    }
+
     /**
      * Adds a document to the star-tree.
      *
@@ -500,7 +539,8 @@ protected StarTreeDocument getSegmentStarTreeDocument(
      */
     Long[] getStarTreeDimensionsFromSegment(int currentDocId, SequentialDocValuesIterator[] dimensionReaders) throws IOException {
         Long[] dimensions = new Long[numDimensions];
-        for (int i = 0; i < numDimensions; i++) {
+        AtomicInteger dimIndex = new AtomicInteger(0);
+        for (int i = 0; i < dimensionReaders.length; i++) {
             if (dimensionReaders[i] != null) {
                 try {
                     dimensionReaders[i].nextEntry(currentDocId);
@@ -511,11 +551,16 @@ Long[] getStarTreeDimensionsFromSegment(int currentDocId, SequentialDocValuesIte
                     logger.error("unable to read the dimension values from the segment", e);
                     throw new IllegalStateException("unable to read the dimension values from the segment", e);
                 }
-                dimensions[i] = dimensionReaders[i].value(currentDocId);
+                dimensionsSplitOrder.get(i).setDimensionValues(dimensionReaders[i].value(currentDocId), value -> {
+                    dimensions[dimIndex.getAndIncrement()] = value;
+                });
             } else {
                 throw new IllegalStateException("dimension readers are empty");
             }
         }
+        if (dimIndex.get() != numDimensions) {
+            throw new IllegalStateException("Values are not set for all dimensions");
+        }
         return dimensions;
     }
 
@@ -685,6 +730,7 @@ private SequentialDocValuesIterator getIteratorForNumericField(
      * @throws IOException throws an exception if we are unable to add the doc
      */
     private void appendToStarTree(StarTreeDocument starTreeDocument) throws IOException {
+
         appendStarTreeDocument(starTreeDocument);
         numStarTreeDocs++;
     }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilder.java
index 11cd9e0c94113..9c39555396397 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilder.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilder.java
@@ -12,13 +12,9 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.codecs.DocValuesConsumer;
 import org.apache.lucene.index.SegmentWriteState;
-import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.store.IndexOutput;
 import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.index.compositeindex.datacube.Dimension;
-import org.opensearch.index.compositeindex.datacube.Metric;
-import org.opensearch.index.compositeindex.datacube.MetricStat;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
 import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
@@ -36,9 +32,6 @@
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import static org.opensearch.index.compositeindex.CompositeIndexConstants.SEGMENT_DOCS_COUNT;
-import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
-
 /**
  * Off-heap implementation of the star tree builder.
  *
@@ -68,9 +61,9 @@ protected OffHeapStarTreeBuilder(
         MapperService mapperService
     ) throws IOException {
         super(metaOut, dataOut, starTreeField, state, mapperService);
-        segmentDocumentFileManager = new SegmentDocsFileManager(state, starTreeField, metricAggregatorInfos);
+        segmentDocumentFileManager = new SegmentDocsFileManager(state, starTreeField, metricAggregatorInfos, numDimensions);
         try {
-            starTreeDocumentFileManager = new StarTreeDocsFileManager(state, starTreeField, metricAggregatorInfos);
+            starTreeDocumentFileManager = new StarTreeDocsFileManager(state, starTreeField, metricAggregatorInfos, numDimensions);
         } catch (IOException e) {
             IOUtils.closeWhileHandlingException(segmentDocumentFileManager);
             throw e;
@@ -147,31 +140,12 @@ Iterator<StarTreeDocument> mergeStarTrees(List<StarTreeValues> starTreeValuesSub
         int[] docIds;
         try {
             for (StarTreeValues starTreeValues : starTreeValuesSubs) {
-                List<Dimension> dimensionsSplitOrder = starTreeValues.getStarTreeField().getDimensionsOrder();
-                SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[starTreeValues.getStarTreeField()
-                    .getDimensionsOrder()
-                    .size()];
-                for (int i = 0; i < dimensionsSplitOrder.size(); i++) {
-                    String dimension = dimensionsSplitOrder.get(i).getField();
-                    dimensionReaders[i] = new SequentialDocValuesIterator(starTreeValues.getDimensionValuesIterator(dimension));
-                }
+                SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[numDimensions];
                 List<SequentialDocValuesIterator> metricReaders = new ArrayList<>();
-                // get doc id set iterators for metrics
-                for (Metric metric : starTreeValues.getStarTreeField().getMetrics()) {
-                    for (MetricStat metricStat : metric.getBaseMetrics()) {
-                        String metricFullName = fullyQualifiedFieldNameForStarTreeMetricsDocValues(
-                            starTreeValues.getStarTreeField().getName(),
-                            metric.getField(),
-                            metricStat.getTypeName()
-                        );
-                        metricReaders.add(new SequentialDocValuesIterator(starTreeValues.getMetricValuesIterator(metricFullName)));
-                    }
-                }
+                AtomicInteger numSegmentDocs = new AtomicInteger();
+                setReadersAndNumSegmentDocs(dimensionReaders, metricReaders, numSegmentDocs, starTreeValues);
                 int currentDocId = 0;
-                int numSegmentDocs = Integer.parseInt(
-                    starTreeValues.getAttributes().getOrDefault(SEGMENT_DOCS_COUNT, String.valueOf(DocIdSetIterator.NO_MORE_DOCS))
-                );
-                while (currentDocId < numSegmentDocs) {
+                while (currentDocId < numSegmentDocs.get()) {
                     StarTreeDocument starTreeDocument = getStarTreeDocument(currentDocId, dimensionReaders, metricReaders);
                     segmentDocumentFileManager.writeStarTreeDocument(starTreeDocument, true);
                     numDocs++;
@@ -317,7 +291,7 @@ public Iterator<StarTreeDocument> generateStarTreeDocumentsForStarNode(int start
             int docId = 1;
 
             private boolean hasSameDimensions(StarTreeDocument document1, StarTreeDocument document2) {
-                for (int i = dimensionId + 1; i < starTreeField.getDimensionsOrder().size(); i++) {
+                for (int i = dimensionId + 1; i < numDimensions; i++) {
                     if (!Objects.equals(document1.dimensions[i], document2.dimensions[i])) {
                         return false;
                     }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java
index 13c6d03c4dc3d..07142fc5c8be7 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java
@@ -9,12 +9,8 @@
 
 import org.apache.lucene.codecs.DocValuesConsumer;
 import org.apache.lucene.index.SegmentWriteState;
-import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.store.IndexOutput;
 import org.opensearch.common.annotation.ExperimentalApi;
-import org.opensearch.index.compositeindex.datacube.Dimension;
-import org.opensearch.index.compositeindex.datacube.Metric;
-import org.opensearch.index.compositeindex.datacube.MetricStat;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
 import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
@@ -29,9 +25,6 @@
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import static org.opensearch.index.compositeindex.CompositeIndexConstants.SEGMENT_DOCS_COUNT;
-import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
-
 /**
  * On heap single tree builder
  *
@@ -133,33 +126,13 @@ Iterator<StarTreeDocument> mergeStarTrees(List<StarTreeValues> starTreeValuesSub
     StarTreeDocument[] getSegmentsStarTreeDocuments(List<StarTreeValues> starTreeValuesSubs) throws IOException {
         List<StarTreeDocument> starTreeDocuments = new ArrayList<>();
         for (StarTreeValues starTreeValues : starTreeValuesSubs) {
-            List<Dimension> dimensionsSplitOrder = starTreeValues.getStarTreeField().getDimensionsOrder();
-            SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[dimensionsSplitOrder.size()];
-
-            for (int i = 0; i < dimensionsSplitOrder.size(); i++) {
-                String dimension = dimensionsSplitOrder.get(i).getField();
-                dimensionReaders[i] = new SequentialDocValuesIterator(starTreeValues.getDimensionValuesIterator(dimension));
-            }
 
+            SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[numDimensions];
             List<SequentialDocValuesIterator> metricReaders = new ArrayList<>();
-            // get doc id set iterators for metrics
-            for (Metric metric : starTreeValues.getStarTreeField().getMetrics()) {
-                for (MetricStat metricStat : metric.getBaseMetrics()) {
-                    String metricFullName = fullyQualifiedFieldNameForStarTreeMetricsDocValues(
-                        starTreeValues.getStarTreeField().getName(),
-                        metric.getField(),
-                        metricStat.getTypeName()
-                    );
-                    metricReaders.add(new SequentialDocValuesIterator(starTreeValues.getMetricValuesIterator(metricFullName)));
-
-                }
-            }
-
+            AtomicInteger numSegmentDocs = new AtomicInteger();
+            setReadersAndNumSegmentDocs(dimensionReaders, metricReaders, numSegmentDocs, starTreeValues);
             int currentDocId = 0;
-            int numSegmentDocs = Integer.parseInt(
-                starTreeValues.getAttributes().getOrDefault(SEGMENT_DOCS_COUNT, String.valueOf(DocIdSetIterator.NO_MORE_DOCS))
-            );
-            while (currentDocId < numSegmentDocs) {
+            while (currentDocId < numSegmentDocs.get()) {
                 starTreeDocuments.add(getStarTreeDocument(currentDocId, dimensionReaders, metricReaders));
                 currentDocId++;
             }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/SegmentDocsFileManager.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/SegmentDocsFileManager.java
index fe94df57d9535..363e02b52d5e3 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/SegmentDocsFileManager.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/SegmentDocsFileManager.java
@@ -40,9 +40,13 @@ public class SegmentDocsFileManager extends AbstractDocumentsFileManager impleme
     private RandomAccessInput segmentRandomInput;
     final IndexOutput segmentDocsFileOutput;
 
-    public SegmentDocsFileManager(SegmentWriteState state, StarTreeField starTreeField, List<MetricAggregatorInfo> metricAggregatorInfos)
-        throws IOException {
-        super(state, starTreeField, metricAggregatorInfos);
+    public SegmentDocsFileManager(
+        SegmentWriteState state,
+        StarTreeField starTreeField,
+        List<MetricAggregatorInfo> metricAggregatorInfos,
+        int numDimensions
+    ) throws IOException {
+        super(state, starTreeField, metricAggregatorInfos, numDimensions);
         try {
             segmentDocsFileOutput = tmpDirectory.createTempOutput(SEGMENT_DOC_FILE_NAME, state.segmentSuffix, state.context);
         } catch (IOException e) {
@@ -78,7 +82,7 @@ public StarTreeDocument readStarTreeDocument(int docId, boolean isAggregatedDoc)
     @Override
     public Long[] readDimensions(int docId) throws IOException {
         maybeInitializeSegmentInput();
-        Long[] dims = new Long[starTreeField.getDimensionsOrder().size()];
+        Long[] dims = new Long[numDimensions];
         readDimensions(dims, segmentRandomInput, (long) docId * docSizeInBytes);
         return dims;
     }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocsFileManager.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocsFileManager.java
index 15ed153249243..7e920b912731d 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocsFileManager.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocsFileManager.java
@@ -60,18 +60,23 @@ public class StarTreeDocsFileManager extends AbstractDocumentsFileManager implem
     private final int fileCountMergeThreshold;
     private int numStarTreeDocs = 0;
 
-    public StarTreeDocsFileManager(SegmentWriteState state, StarTreeField starTreeField, List<MetricAggregatorInfo> metricAggregatorInfos)
-        throws IOException {
-        this(state, starTreeField, metricAggregatorInfos, DEFAULT_FILE_COUNT_MERGE_THRESHOLD);
+    public StarTreeDocsFileManager(
+        SegmentWriteState state,
+        StarTreeField starTreeField,
+        List<MetricAggregatorInfo> metricAggregatorInfos,
+        int numDimensions
+    ) throws IOException {
+        this(state, starTreeField, metricAggregatorInfos, DEFAULT_FILE_COUNT_MERGE_THRESHOLD, numDimensions);
     }
 
     public StarTreeDocsFileManager(
         SegmentWriteState state,
         StarTreeField starTreeField,
         List<MetricAggregatorInfo> metricAggregatorInfos,
-        int fileCountThreshold
+        int fileCountThreshold,
+        int numDimensions
     ) throws IOException {
-        super(state, starTreeField, metricAggregatorInfos);
+        super(state, starTreeField, metricAggregatorInfos, numDimensions);
         fileToEndDocIdMap = new LinkedHashMap<>();
         try {
             starTreeDocsFileOutput = createStarTreeDocumentsFileOutput();
@@ -126,7 +131,7 @@ public Long getDimensionValue(int docId, int dimensionId) throws IOException {
     @Override
     public Long[] readDimensions(int docId) throws IOException {
         ensureDocumentReadable(docId);
-        Long[] dims = new Long[starTreeField.getDimensionsOrder().size()];
+        Long[] dims = new Long[numDimensions];
         readDimensions(dims, starTreeDocsFileRandomInput, getOffset(docId));
         return dims;
     }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataWriter.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataWriter.java
index 1c04350e25047..42e6f3c59866a 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataWriter.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataWriter.java
@@ -11,7 +11,6 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.store.IndexOutput;
-import org.opensearch.index.compositeindex.datacube.Dimension;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
 import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
 import org.opensearch.index.mapper.CompositeMappedFieldType;
@@ -128,13 +127,11 @@ private static void writeMeta(
         metaOut.writeVInt(numNodes);
 
         // number of dimensions
-        // TODO: Revisit the number of dimensions for timestamps (as we will split timestamp into min, hour, etc.)
-        metaOut.writeVInt(starTreeField.getDimensionsOrder().size());
+        metaOut.writeVInt(starTreeField.getDimensionNames().size());
 
         // dimensions
-        // TODO: Add sub-dimensions for timestamps (as we will split timestamp into min, hour, etc.)
-        for (Dimension dimension : starTreeField.getDimensionsOrder()) {
-            metaOut.writeString(dimension.getField());
+        for (String dim : starTreeField.getDimensionNames()) {
+            metaOut.writeString(dim);
         }
 
         // number of metrics
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/DateTimeUnitAdapter.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/DateTimeUnitAdapter.java
new file mode 100644
index 0000000000000..b18ac33a8f657
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/DateTimeUnitAdapter.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils.date;
+
+import org.opensearch.common.Rounding;
+
+import java.util.Objects;
+
+/**
+ * Adapter class to convert {@link Rounding.DateTimeUnit} to {@link DateTimeUnitRounding}
+ *
+ * @opensearch.experimental
+ */
+public class DateTimeUnitAdapter implements DateTimeUnitRounding {
+    private final Rounding.DateTimeUnit dateTimeUnit;
+
+    public DateTimeUnitAdapter(Rounding.DateTimeUnit dateTimeUnit) {
+        this.dateTimeUnit = dateTimeUnit;
+    }
+
+    @Override
+    public String shortName() {
+        return dateTimeUnit.shortName();
+    }
+
+    @Override
+    public long roundFloor(long utcMillis) {
+        return dateTimeUnit.roundFloor(utcMillis);
+    }
+
+    /**
+     * Checks if this DateTimeUnitRounding is equal to another object.
+     * Two DateTimeUnitRounding instances are considered equal if they have the same short name.
+     *
+     * @param obj The object to compare with
+     * @return true if the objects are equal, false otherwise
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof DateTimeUnitRounding)) return false;
+        DateTimeUnitRounding other = (DateTimeUnitRounding) obj;
+        return Objects.equals(shortName(), other.shortName());
+    }
+
+    /**
+     * Returns a hash code value for the object.
+     * This method is implemented to be consistent with equals.
+     *
+     * @return a hash code value for this object
+     */
+    @Override
+    public int hashCode() {
+        return Objects.hash(shortName());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/DateTimeUnitRounding.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/DateTimeUnitRounding.java
new file mode 100644
index 0000000000000..93212a2424e46
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/DateTimeUnitRounding.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils.date;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * Interface for rounding time units in starTree
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface DateTimeUnitRounding {
+    /**
+     * Returns the short name of the time unit
+     */
+    String shortName();
+
+    /**
+     * rounds down the given utcMillis to the nearest unit of time
+     */
+    long roundFloor(long utcMillis);
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/package-info.java
new file mode 100644
index 0000000000000..bb285c894e3e0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/date/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Classes and utilities for working with dateTimeUnits
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.utils.date;
diff --git a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
index 778b130b75e55..aece93b90aa18 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
@@ -55,6 +55,7 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.LocaleUtils;
+import org.opensearch.index.compositeindex.datacube.DimensionType;
 import org.opensearch.index.fielddata.IndexFieldData;
 import org.opensearch.index.fielddata.IndexNumericFieldData.NumericType;
 import org.opensearch.index.fielddata.plain.SortedNumericIndexFieldData;
@@ -77,6 +78,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
@@ -340,6 +342,10 @@ public DateFieldMapper build(BuilderContext context) {
             return new DateFieldMapper(name, ft, multiFieldsBuilder.build(this, context), copyTo.build(), nullTimestamp, resolution, this);
         }
 
+        @Override
+        public Optional<DimensionType> getSupportedDataCubeDimensionType() {
+            return Optional.of(DimensionType.DATE);
+        }
     }
 
     public static final TypeParser MILLIS_PARSER = new TypeParser((n, c) -> {
diff --git a/server/src/main/java/org/opensearch/index/mapper/StarTreeMapper.java b/server/src/main/java/org/opensearch/index/mapper/StarTreeMapper.java
index 52dab17e0b0bb..40f05a8b76755 100644
--- a/server/src/main/java/org/opensearch/index/mapper/StarTreeMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/StarTreeMapper.java
@@ -11,6 +11,7 @@
 import org.apache.lucene.search.Query;
 import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.xcontent.support.XContentMapValues;
+import org.opensearch.index.compositeindex.datacube.DateDimension;
 import org.opensearch.index.compositeindex.datacube.Dimension;
 import org.opensearch.index.compositeindex.datacube.DimensionFactory;
 import org.opensearch.index.compositeindex.datacube.Metric;
@@ -44,8 +45,8 @@ public class StarTreeMapper extends ParametrizedFieldMapper {
     public static final String CONFIG = "config";
     public static final String MAX_LEAF_DOCS = "max_leaf_docs";
     public static final String SKIP_STAR_NODE_IN_DIMS = "skip_star_node_creation_for_dimensions";
-    public static final String BUILD_MODE = "build_mode";
     public static final String ORDERED_DIMENSIONS = "ordered_dimensions";
+    public static final String DATE_DIMENSION = "date_dimension";
     public static final String METRICS = "metrics";
     public static final String STATS = "stats";
 
@@ -84,6 +85,7 @@ public static class Builder extends ParametrizedFieldMapper.Builder {
                 StarTreeFieldConfiguration.StarTreeBuildMode buildMode = StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP;
 
                 List<Dimension> dimensions = buildDimensions(name, paramMap, context);
+                paramMap.remove(DATE_DIMENSION);
                 paramMap.remove(ORDERED_DIMENSIONS);
                 List<Metric> metrics = buildMetrics(name, paramMap, context);
                 paramMap.remove(METRICS);
@@ -119,16 +121,21 @@ public static class Builder extends ParametrizedFieldMapper.Builder {
          */
         @SuppressWarnings("unchecked")
         private List<Dimension> buildDimensions(String fieldName, Map<String, Object> map, Mapper.TypeParser.ParserContext context) {
+            List<Dimension> dimensions = new LinkedList<>();
+            DateDimension dateDim = buildDateDimension(fieldName, map, context);
+            if (dateDim != null) {
+                dimensions.add(dateDim);
+            }
             Object dims = XContentMapValues.extractValue("ordered_dimensions", map);
             if (dims == null) {
                 throw new IllegalArgumentException(
                     String.format(Locale.ROOT, "ordered_dimensions is required for star tree field [%s]", fieldName)
                 );
             }
-            List<Dimension> dimensions = new LinkedList<>();
+
             if (dims instanceof List<?>) {
-                List<Object> dimList = (List<Object>) dims;
-                if (dimList.size() > context.getSettings()
+                List<Object> orderedDimensionsList = (List<Object>) dims;
+                if (orderedDimensionsList.size() + dimensions.size() > context.getSettings()
                     .getAsInt(
                         StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_SETTING.getKey(),
                         StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_DEFAULT
@@ -146,13 +153,13 @@ private List<Dimension> buildDimensions(String fieldName, Map<String, Object> ma
                         )
                     );
                 }
-                if (dimList.size() < 2) {
+                if (dimensions.size() + orderedDimensionsList.size() < 2) {
                     throw new IllegalArgumentException(
                         String.format(Locale.ROOT, "Atleast two dimensions are required to build star tree index field [%s]", fieldName)
                     );
                 }
                 Set<String> dimensionFieldNames = new HashSet<>();
-                for (Object dim : dimList) {
+                for (Object dim : orderedDimensionsList) {
                     Dimension dimension = getDimension(fieldName, dim, context);
                     if (dimensionFieldNames.add(dimension.getField()) == false) {
                         throw new IllegalArgumentException(
@@ -174,6 +181,52 @@ private List<Dimension> buildDimensions(String fieldName, Map<String, Object> ma
             return dimensions;
         }
 
+        private DateDimension buildDateDimension(String fieldName, Map<String, Object> map, Mapper.TypeParser.ParserContext context) {
+            Object dims = XContentMapValues.extractValue("date_dimension", map);
+            if (dims == null) {
+                return null;
+            }
+            return getDateDimension(fieldName, dims, context);
+        }
+
+        /**
+         * Get dimension based on mapping
+         */
+        @SuppressWarnings("unchecked")
+        private DateDimension getDateDimension(String fieldName, Object dimensionMapping, Mapper.TypeParser.ParserContext context) {
+            DateDimension dimension;
+            Map<String, Object> dimensionMap = (Map<String, Object>) dimensionMapping;
+            String name = (String) XContentMapValues.extractValue(CompositeDataCubeFieldType.NAME, dimensionMap);
+            dimensionMap.remove(CompositeDataCubeFieldType.NAME);
+            if (this.objbuilder == null || this.objbuilder.mappersBuilders == null) {
+                String type = (String) XContentMapValues.extractValue(CompositeDataCubeFieldType.TYPE, dimensionMap);
+                dimensionMap.remove(CompositeDataCubeFieldType.TYPE);
+                if (type == null || type.equals(DateDimension.DATE) == false) {
+                    throw new MapperParsingException(
+                        String.format(Locale.ROOT, "unable to parse date dimension for star tree field [%s]", fieldName)
+                    );
+                }
+                return (DateDimension) DimensionFactory.parseAndCreateDimension(name, type, dimensionMap, context);
+            } else {
+                Optional<Mapper.Builder> dimBuilder = findMapperBuilderByName(name, this.objbuilder.mappersBuilders);
+                if (dimBuilder.isEmpty()) {
+                    throw new IllegalArgumentException(String.format(Locale.ROOT, "unknown date dimension field [%s]", name));
+                }
+                if (dimBuilder.get() instanceof DateFieldMapper.Builder == false) {
+                    throw new IllegalArgumentException(
+                        String.format(Locale.ROOT, "date_dimension [%s] should be of type date for star tree field [%s]", name, fieldName)
+                    );
+                }
+                dimension = (DateDimension) DimensionFactory.parseAndCreateDimension(name, dimBuilder.get(), dimensionMap, context);
+            }
+            DocumentMapperParser.checkNoRemainingFields(
+                dimensionMap,
+                context.indexVersionCreated(),
+                "Star tree mapping definition has unsupported parameters: "
+            );
+            return dimension;
+        }
+
         /**
          * Get dimension based on mapping
          */
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/DateDimensionTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/DateDimensionTests.java
new file mode 100644
index 0000000000000..0aa563ed0cafd
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/DateDimensionTests.java
@@ -0,0 +1,365 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree;
+
+import org.opensearch.common.Rounding;
+import org.opensearch.index.compositeindex.datacube.DataCubeDateTimeUnit;
+import org.opensearch.index.compositeindex.datacube.DateDimension;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitAdapter;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitRounding;
+import org.opensearch.index.mapper.DateFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.opensearch.index.compositeindex.datacube.DateDimension.DateTimeUnitComparator.ORDERED_DATE_TIME_UNIT;
+
+public class DateDimensionTests extends OpenSearchTestCase {
+    public void testDateDimension() {
+        String field = "timestamp";
+        List<DateTimeUnitRounding> intervals = Arrays.asList(
+            DataCubeDateTimeUnit.HALF_HOUR_OF_DAY,
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.MONTH_OF_YEAR),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.YEAR_OF_CENTURY)
+        );
+        DateDimension dateDimension = new DateDimension(field, intervals, DateFieldMapper.Resolution.MILLISECONDS);
+
+        assertEquals(field, dateDimension.getField());
+        assertEquals(intervals, dateDimension.getIntervals());
+        for (int i = 0; i < intervals.size(); i++) {
+            assertEquals(intervals.get(i).shortName(), dateDimension.getSortedCalendarIntervals().get(i).shortName());
+        }
+    }
+
+    public void testSetDimensionValuesWithMultipleIntervalsYear() {
+        List<DateTimeUnitRounding> intervals = Arrays.asList(
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.YEAR_OF_CENTURY),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.MONTH_OF_YEAR),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.DAY_OF_MONTH),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY)
+        );
+        DateDimension dateDimension = new DateDimension("timestamp", intervals, DateFieldMapper.Resolution.MILLISECONDS);
+        Long[] dims = new Long[4];
+        Long testValue = 1609459200000L; // 2021-01-01 00:00:00 UTC
+
+        AtomicInteger dimIndex = new AtomicInteger(0);
+        dateDimension.setDimensionValues(testValue, value -> { dims[dimIndex.getAndIncrement()] = value; });
+
+        assertEquals(4, dimIndex.get());
+        assertEquals(1609459200000L, (long) dims[0]); // Hour rounded
+        assertEquals(1609459200000L, (long) dims[1]); // Day rounded
+        assertEquals(1609459200000L, (long) dims[2]); // Month rounded
+        assertEquals(1609459200000L, (long) dims[3]); // Year rounded
+        assertEquals(4, dateDimension.getNumSubDimensions());
+    }
+
+    public void testSetDimensionValuesForHalfAndQuarterHour() {
+        List<DateTimeUnitRounding> intervals = Arrays.asList(
+            DataCubeDateTimeUnit.HALF_HOUR_OF_DAY,
+            DataCubeDateTimeUnit.QUARTER_HOUR_OF_DAY
+        );
+        DateDimension dateDimension = new DateDimension("timestamp", intervals, DateFieldMapper.Resolution.MILLISECONDS);
+        Long[] dims = new Long[2];
+        long testValue = 1724230620123L; // August 21, 2024 8:57:00.123 UTC
+
+        AtomicInteger dimIndex = new AtomicInteger(0);
+        dateDimension.setDimensionValues(testValue, value -> { dims[dimIndex.getAndIncrement()] = value; });
+
+        assertEquals(2, dimIndex.get());
+        assertEquals(1724229900000L, (long) dims[0]); // Quarter Hour rounded - Wed, 21 Aug 2024 08:45:00 UTC
+        assertEquals(1724229000000L, (long) dims[1]); // Half hour rounded - Wed, 21 Aug 2024 08:30:00 UTC
+        assertEquals(2, dateDimension.getNumSubDimensions());
+
+        Long[] dims1 = new Long[2];
+        testValue = 1724229899234L; // Wed, 21 Aug 2024 08:44:59 GMT
+
+        AtomicInteger dimIndex1 = new AtomicInteger(0);
+        dateDimension.setDimensionValues(testValue, value -> { dims1[dimIndex1.getAndIncrement()] = value; });
+
+        assertEquals(1724229000000L, (long) dims1[0]); // Quarter Hour rounded - Wed, 21 Aug 2024 08:30:00 UTC
+        assertEquals(1724229000000L, (long) dims1[1]); // Half hour rounded - Wed, 21 Aug 2024 08:30:00 UTC
+        assertEquals(2, dateDimension.getNumSubDimensions());
+
+        Long[] dims2 = new Long[2];
+        testValue = 1724229000123L; // Wed, 21 Aug 2024 08:30:00 GMT
+
+        AtomicInteger dimIndex2 = new AtomicInteger(0);
+        dateDimension.setDimensionValues(testValue, value -> { dims2[dimIndex2.getAndIncrement()] = value; });
+
+        assertEquals(2, dimIndex2.get());
+        assertEquals(1724229000000L, (long) dims2[0]); // Quarter Hour rounded - Wed, 21 Aug 2024 08:30:00 UTC
+        assertEquals(1724229000000L, (long) dims2[1]); // Half hour rounded - Wed, 21 Aug 2024 08:30:00 UTC
+        assertEquals(2, dateDimension.getNumSubDimensions());
+
+        Long[] dims3 = new Long[2];
+        testValue = 1724228940000L; // Wed, 21 Aug 2024 08:29:00 GMT
+
+        AtomicInteger dimIndex3 = new AtomicInteger(0);
+        dateDimension.setDimensionValues(testValue, value -> { dims3[dimIndex3.getAndIncrement()] = value; });
+
+        assertEquals(2, dimIndex3.get());
+        assertEquals(1724228100000L, (long) dims3[0]); // Quarter Hour rounded - Wed, 21 Aug 2024 08:15:00 UTC
+        assertEquals(1724227200000L, (long) dims3[1]); // Half hour rounded - Wed, 21 Aug 2024 08:00:00 UTC
+        assertEquals(2, dateDimension.getNumSubDimensions());
+    }
+
+    public void testRoundingAndSortingAllDateTimeUnitsNanos() {
+        List<DateTimeUnitRounding> allUnits = getAllTimeUnits();
+
+        DateDimension dateDimension = new DateDimension("timestamp", allUnits, DateFieldMapper.Resolution.NANOSECONDS);
+
+        // Test sorting
+        List<DateTimeUnitRounding> sortedUnits = dateDimension.getSortedCalendarIntervals();
+        assertEquals(allUnits.size(), sortedUnits.size());
+        for (int i = 0; i < sortedUnits.size() - 1; i++) {
+            assertTrue(
+                "Units should be sorted in ascending order",
+                ORDERED_DATE_TIME_UNIT.get(sortedUnits.get(i).shortName())
+                    .compareTo(ORDERED_DATE_TIME_UNIT.get(sortedUnits.get(i + 1).shortName())) <= 0
+            );
+        }
+
+        // Test rounding
+        long testValueNanos = 1655293505382719622L; // 2022-06-15T11:45:05.382719622Z
+        Long[] dims = new Long[allUnits.size()];
+
+        AtomicInteger dimIndex = new AtomicInteger(0);
+        dateDimension.setDimensionValues(testValueNanos, value -> { dims[dimIndex.getAndIncrement()] = value; });
+
+        // Expected rounded values (in nanoseconds)
+        long secondRounded = 1655293505000L; // 2022-06-15T11:45:05Z
+        long minuteRounded = 1655293500000L; // 2022-06-15T11:45:00Z
+        long quarterHourRounded = 1655293500000L; // 2022-06-15T11:45:00Z
+        long halfHourRounded = 1655292600000L; // 2022-06-15T11:30:00Z
+        long hourRounded = 1655290800000L; // 2022-06-15T11:00:00Z
+        long dayRounded = 1655251200000L; // 2022-06-15T00:00:00Z
+        long weekRounded = 1655078400000L; // 2022-06-13T00:00:00Z (Monday)
+        long monthRounded = 1654041600000L; // 2022-06-01T00:00:00Z
+        long quarterRounded = 1648771200000L; // 2022-04-01T00:00:00Z
+        long yearRounded = 1640995200000L; // 2022-01-01T00:00:00Z
+
+        assertTimeUnits(
+            sortedUnits,
+            dims,
+            secondRounded,
+            minuteRounded,
+            hourRounded,
+            dayRounded,
+            weekRounded,
+            monthRounded,
+            quarterRounded,
+            yearRounded,
+            halfHourRounded,
+            quarterHourRounded
+        );
+    }
+
+    public void testRoundingAndSortingAllDateTimeUnitsMillis() {
+        List<DateTimeUnitRounding> allUnits = getAllTimeUnits();
+
+        DateDimension dateDimension = new DateDimension("timestamp", allUnits, DateFieldMapper.Resolution.MILLISECONDS);
+
+        // Test sorting
+        List<DateTimeUnitRounding> sortedUnits = dateDimension.getSortedCalendarIntervals();
+        assertEquals(allUnits.size(), sortedUnits.size());
+        for (int i = 0; i < sortedUnits.size() - 1; i++) {
+            assertTrue(
+                "Units should be sorted in ascending order",
+                ORDERED_DATE_TIME_UNIT.get(sortedUnits.get(i).shortName())
+                    .compareTo(ORDERED_DATE_TIME_UNIT.get(sortedUnits.get(i + 1).shortName())) <= 0
+            );
+        }
+
+        // Test rounding
+        long testValueNanos = 1724114825234L; // 2024-08-20T00:47:05.234Z
+        Long[] dims = new Long[allUnits.size()];
+
+        AtomicInteger dimIndex = new AtomicInteger(0);
+        dateDimension.setDimensionValues(testValueNanos, value -> { dims[dimIndex.getAndIncrement()] = value; });
+
+        // Expected rounded values (in millis)
+        long secondRounded = 1724114825000L; // 2024-08-20T00:47:05.000Z
+        long minuteRounded = 1724114820000L; // 2024-08-20T00:47:00.000Z
+        long quarterHourRounded = 1724114700000L; // 2024-08-20T00:45:00.000Z
+        long halfHourRounded = 1724113800000L; // 2024-08-20T00:30:00.000Z
+        long hourRounded = 1724112000000L; // 2024-08-20T00:00:00.000Z
+        long dayRounded = 1724112000000L; // 2024-08-20T00:00:00.000Z
+        long weekRounded = 1724025600000L; // 2024-08-15T00:00:00.000Z (Monday)
+        long monthRounded = 1722470400000L; // 2024-08-01T00:00:00.000Z
+        long quarterRounded = 1719792000000L; // 2024-07-01T00:00:00.000Z
+        long yearRounded = 1704067200000L; // 2024-01-01T00:00:00.000Z
+
+        assertTimeUnits(
+            sortedUnits,
+            dims,
+            secondRounded,
+            minuteRounded,
+            hourRounded,
+            dayRounded,
+            weekRounded,
+            monthRounded,
+            quarterRounded,
+            yearRounded,
+            halfHourRounded,
+            quarterHourRounded
+        );
+    }
+
+    private static List<DateTimeUnitRounding> getAllTimeUnits() {
+        return Arrays.asList(
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.WEEK_OF_WEEKYEAR),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.MONTH_OF_YEAR),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.QUARTER_OF_YEAR),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.YEAR_OF_CENTURY),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.SECOND_OF_MINUTE),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.MINUTES_OF_HOUR),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY),
+            new DateTimeUnitAdapter(Rounding.DateTimeUnit.DAY_OF_MONTH),
+            DataCubeDateTimeUnit.HALF_HOUR_OF_DAY,
+            DataCubeDateTimeUnit.QUARTER_HOUR_OF_DAY
+        );
+    }
+
+    private static void assertTimeUnits(
+        List<DateTimeUnitRounding> sortedUnits,
+        Long[] dims,
+        long secondRounded,
+        long minuteRounded,
+        long hourRounded,
+        long dayRounded,
+        long weekRounded,
+        long monthRounded,
+        long quarterRounded,
+        long yearRounded,
+        long halfHourRounded,
+        long quarterHourRounded
+    ) {
+        for (int i = 0; i < sortedUnits.size(); i++) {
+            DateTimeUnitRounding unit = sortedUnits.get(i);
+            String unitName = unit.shortName();
+            switch (unitName) {
+                case "second":
+                    assertEquals(secondRounded, (long) dims[i]);
+                    break;
+                case "minute":
+                    assertEquals(minuteRounded, (long) dims[i]);
+                    break;
+                case "hour":
+                    assertEquals(hourRounded, (long) dims[i]);
+                    break;
+                case "day":
+                    assertEquals(dayRounded, (long) dims[i]);
+                    break;
+                case "week":
+                    assertEquals(weekRounded, (long) dims[i]);
+                    break;
+                case "month":
+                    assertEquals(monthRounded, (long) dims[i]);
+                    break;
+                case "quarter":
+                    assertEquals(quarterRounded, (long) dims[i]);
+                    break;
+                case "year":
+                    assertEquals(yearRounded, (long) dims[i]);
+                    break;
+                case "half-hour":
+                    assertEquals(halfHourRounded, (long) dims[i]);
+                    break;
+                case "quarter-hour":
+                    assertEquals(quarterHourRounded, (long) dims[i]);
+                    break;
+                default:
+                    fail("Unexpected DateTimeUnit: " + unit);
+            }
+        }
+    }
+
+    public void testGetSubDimensionNames() {
+        DateDimension dateDimension = new DateDimension(
+            "timestamp",
+            Arrays.asList(
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY),
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.DAY_OF_MONTH)
+            ),
+            DateFieldMapper.Resolution.MILLISECONDS
+        );
+
+        List<String> fields = dateDimension.getSubDimensionNames();
+
+        assertEquals(2, fields.size());
+        assertEquals("timestamp_hour", fields.get(0));
+        assertEquals("timestamp_day", fields.get(1));
+    }
+
+    public void testGetExtendedTimeUnitFieldsNames() {
+        DateDimension dateDimension = new DateDimension(
+            "timestamp",
+            Arrays.asList(DataCubeDateTimeUnit.HALF_HOUR_OF_DAY, DataCubeDateTimeUnit.QUARTER_HOUR_OF_DAY),
+            DateFieldMapper.Resolution.MILLISECONDS
+        );
+
+        List<String> fields = dateDimension.getSubDimensionNames();
+
+        assertEquals(2, fields.size());
+        assertEquals("timestamp_quarter-hour", fields.get(0));
+        assertEquals("timestamp_half-hour", fields.get(1));
+    }
+
+    public void testSetDimensionValues() {
+        DateDimension dateDimension = new DateDimension(
+            "timestamp",
+            Arrays.asList(
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.YEAR_OF_CENTURY),
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY)
+            ),
+            DateFieldMapper.Resolution.MILLISECONDS
+        );
+        Long[] dims = new Long[2];
+        Long testValue = 1609459200000L; // 2021-01-01 00:00:00 UTC
+
+        AtomicInteger dimIndex = new AtomicInteger(0);
+        dateDimension.setDimensionValues(testValue, value -> { dims[dimIndex.getAndIncrement()] = value; });
+
+        assertEquals(2, dimIndex.get());
+        assertEquals(1609459200000L, (long) dims[0]); // Hour rounded
+        assertEquals(1609459200000L, (long) dims[1]); // Year rounded
+    }
+
+    public void testDateTimeUnitComparator() {
+        Comparator<DateTimeUnitRounding> comparator = new DateDimension.DateTimeUnitComparator();
+        assertTrue(
+            comparator.compare(
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.SECOND_OF_MINUTE),
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.MINUTES_OF_HOUR)
+            ) < 0
+        );
+        assertTrue(
+            comparator.compare(
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY),
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.DAY_OF_MONTH)
+            ) < 0
+        );
+        assertTrue(
+            comparator.compare(
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.YEAR_OF_CENTURY),
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.MONTH_OF_YEAR)
+            ) > 0
+        );
+        assertEquals(
+            0,
+            comparator.compare(
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.WEEK_OF_WEEKYEAR),
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.WEEK_OF_WEEKYEAR)
+            )
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeTestUtils.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeTestUtils.java
index 7cae1cd25ee93..dc8b3320f3de2 100644
--- a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeTestUtils.java
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeTestUtils.java
@@ -50,11 +50,19 @@ public static StarTreeDocument[] getSegmentsStarTreeDocuments(
         List<StarTreeDocument> starTreeDocuments = new ArrayList<>();
         for (StarTreeValues starTreeValues : starTreeValuesSubs) {
             List<Dimension> dimensionsSplitOrder = starTreeValues.getStarTreeField().getDimensionsOrder();
-            SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[dimensionsSplitOrder.size()];
+            int numDimensions = 0;
+            for (Dimension dimension : dimensionsSplitOrder) {
+                numDimensions += dimension.getNumSubDimensions();
+            }
+            SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[numDimensions];
 
+            int dimIndex = 0;
             for (int i = 0; i < dimensionsSplitOrder.size(); i++) {
-                String dimension = dimensionsSplitOrder.get(i).getField();
-                dimensionReaders[i] = new SequentialDocValuesIterator(starTreeValues.getDimensionValuesIterator(dimension));
+                Dimension dimension = dimensionsSplitOrder.get(i);
+                for (String name : dimension.getSubDimensionNames()) {
+                    dimensionReaders[dimIndex] = new SequentialDocValuesIterator(starTreeValues.getDimensionValuesIterator(name));
+                    dimIndex++;
+                }
             }
 
             List<SequentialDocValuesIterator> metricReaders = new ArrayList<>();
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractStarTreeBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractStarTreeBuilderTests.java
index 95fd1579c2f63..0d4e4c37d6924 100644
--- a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractStarTreeBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractStarTreeBuilderTests.java
@@ -33,12 +33,15 @@
 import org.apache.lucene.util.InfoStream;
 import org.apache.lucene.util.NumericUtils;
 import org.apache.lucene.util.Version;
+import org.opensearch.common.Rounding;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.index.codec.composite.LuceneDocValuesConsumerFactory;
 import org.opensearch.index.codec.composite.LuceneDocValuesProducerFactory;
 import org.opensearch.index.codec.composite.composite99.Composite99Codec;
 import org.opensearch.index.codec.composite.composite99.Composite99DocValuesFormat;
 import org.opensearch.index.compositeindex.CompositeIndexConstants;
+import org.opensearch.index.compositeindex.datacube.DataCubeDateTimeUnit;
+import org.opensearch.index.compositeindex.datacube.DateDimension;
 import org.opensearch.index.compositeindex.datacube.Dimension;
 import org.opensearch.index.compositeindex.datacube.Metric;
 import org.opensearch.index.compositeindex.datacube.MetricStat;
@@ -53,9 +56,12 @@
 import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNodeType;
 import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
 import org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitAdapter;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitRounding;
 import org.opensearch.index.compositeindex.datacube.startree.utils.iterator.SortedNumericStarTreeValuesIterator;
 import org.opensearch.index.compositeindex.datacube.startree.utils.iterator.StarTreeValuesIterator;
 import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.FieldValueConverter;
 import org.opensearch.index.mapper.Mapper;
@@ -84,6 +90,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
 
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.SEGMENT_DOCS_COUNT;
 import static org.opensearch.index.compositeindex.datacube.startree.StarTreeTestUtils.validateFileFormats;
 import static org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter.VERSION_CURRENT;
 import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeDimensionsDocValues;
@@ -1864,7 +1871,7 @@ private List<String> getStarTreeDimensionNames(List<Dimension> dimensionsOrder)
 
         List<String> dimensionNames = new ArrayList<>();
         for (Dimension dimension : dimensionsOrder) {
-            dimensionNames.add(dimension.getField());
+            dimensionNames.addAll(dimension.getSubDimensionNames());
         }
         return dimensionNames;
 
@@ -3842,7 +3849,7 @@ public void testMergeFlowWithDuplicateDimensionValueWithMaxLeafDocs() throws IOE
     }
 
     public static long getLongFromDouble(double value) {
-        return Double.doubleToLongBits(value);
+        return NumericUtils.doubleToSortableLong(value);
     }
 
     public void testMergeFlowWithMaxLeafDocsAndStarTreeNodesAssertion() throws IOException {
@@ -4199,9 +4206,11 @@ public void testMergeFlow() throws IOException {
          ...
          [999, 999, 999, 999] | [19980.0]
          */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
         for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
             assertEquals(starTreeDocument.dimensions[0] * 20.0, starTreeDocument.metrics[0]);
-            assertEquals(2L, starTreeDocument.metrics[1]);
+            assertEquals(starTreeDocument.dimensions[0] * 2, starTreeDocument.metrics[1]);
+            assertEquals(2L, starTreeDocument.metrics[2]);
         }
         builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
 
@@ -4213,7 +4222,7 @@ public void testMergeFlow() throws IOException {
         docValuesConsumer.close();
 
         StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
-            "sf",
+            compositeField.getName(),
             STAR_TREE,
             mock(IndexInput.class),
             VERSION_CURRENT,
@@ -4237,6 +4246,251 @@ public void testMergeFlow() throws IOException {
         );
     }
 
+    public void testFlushFlowWithTimestamps() throws IOException {
+        List<Long> dimList = List.of(1655288152000L, 1655288092000L, 1655288032000L, 1655287972000L, 1655288092000L);
+        List<Integer> docsWithField = List.of(0, 1, 3, 4, 5);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5);
+
+        List<Long> metricsList = List.of(
+            getLongFromDouble(0.0),
+            getLongFromDouble(10.0),
+            getLongFromDouble(20.0),
+            getLongFromDouble(30.0),
+            getLongFromDouble(40.0),
+            getLongFromDouble(50.0)
+        );
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5);
+
+        compositeField = getStarTreeFieldWithDateDimension();
+        SortedNumericStarTreeValuesIterator d1sndv = new SortedNumericStarTreeValuesIterator(getSortedNumericMock(dimList, docsWithField));
+        SortedNumericStarTreeValuesIterator d2sndv = new SortedNumericStarTreeValuesIterator(
+            getSortedNumericMock(dimList2, docsWithField2)
+        );
+        SortedNumericStarTreeValuesIterator m1sndv = new SortedNumericStarTreeValuesIterator(
+            getSortedNumericMock(metricsList, metricsWithField)
+        );
+        SortedNumericStarTreeValuesIterator m2sndv = new SortedNumericStarTreeValuesIterator(
+            getSortedNumericMock(metricsList, metricsWithField)
+        );
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, getWriteState(6, writeState.segmentInfo.getId()), mapperService);
+        SequentialDocValuesIterator[] dimDvs = { new SequentialDocValuesIterator(d1sndv), new SequentialDocValuesIterator(d2sndv) };
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimDvs,
+            List.of(new SequentialDocValuesIterator(m1sndv), new SequentialDocValuesIterator(m2sndv))
+        );
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Sum [metric], count [metric] ]
+         [1655287920000, 1655287200000, 1655287200000, 4] | [40.0, 1]
+         [1655287980000, 1655287200000, 1655287200000, 3] | [30.0, 1]
+         [1655288040000, 1655287200000, 1655287200000, 1] | [10.0, 1]
+         [1655288040000, 1655287200000, 1655287200000, 5] | [50.0, 1]
+         [1655288100000, 1655287200000, 1655287200000, 0] | [0.0, 1]
+         [null, null, null, 2] | [20.0, 1]
+         */
+        int count = 0;
+        List<StarTreeDocument> starTreeDocumentsList = new ArrayList<>();
+        starTreeDocumentIterator.forEachRemaining(starTreeDocumentsList::add);
+        starTreeDocumentIterator = starTreeDocumentsList.iterator();
+        while (starTreeDocumentIterator.hasNext()) {
+            count++;
+            StarTreeDocument starTreeDocument = starTreeDocumentIterator.next();
+            assertEquals(starTreeDocument.dimensions[3] * 1 * 10.0, starTreeDocument.metrics[1]);
+            assertEquals(1L, starTreeDocument.metrics[0]);
+        }
+        assertEquals(6, count);
+        builder.build(starTreeDocumentsList.iterator(), new AtomicInteger(), docValuesConsumer);
+        validateStarTree(builder.getRootNode(), 3, 10, builder.getStarTreeDocuments());
+    }
+
+    public void testMergeFlowWithTimestamps() throws IOException {
+        List<Long> dimList = List.of(1655288152000L, 1655288092000L, 1655288032000L, 1655287972000L, 1655288092000L, 1655288092000L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 3, 4, 6);
+        List<Long> dimList2 = List.of(1655288152000L, 1655288092000L, 1655288032000L, 1655287972000L, 1655288092000L, 1655288092000L, -1L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 6);
+        List<Long> dimList7 = List.of(1655288152000L, 1655288092000L, 1655288032000L, 1655287972000L, 1655288092000L, 1655288092000L, -1L);
+        List<Integer> docsWithField7 = List.of(0, 1, 2, 3, 4, 6);
+
+        List<Long> dimList5 = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> docsWithField5 = List.of(0, 1, 2, 3, 4, 5, 6);
+        List<Long> metricsList1 = List.of(
+            getLongFromDouble(0.0),
+            getLongFromDouble(10.0),
+            getLongFromDouble(20.0),
+            getLongFromDouble(30.0),
+            getLongFromDouble(40.0),
+            getLongFromDouble(50.0),
+            getLongFromDouble(60.0)
+        );
+        List<Integer> metricsWithField1 = List.of(0, 1, 2, 3, 4, 5, 6);
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> dimList3 = List.of(1655288152000L, 1655288092000L, 1655288032000L, -1L);
+        List<Integer> docsWithField3 = List.of(0, 1, 3, 4);
+        List<Long> dimList4 = List.of(1655288152000L, 1655288092000L, 1655288032000L, -1L);
+        List<Integer> docsWithField4 = List.of(0, 1, 3, 4);
+        List<Long> dimList8 = List.of(1655288152000L, 1655288092000L, 1655288032000L, -1L);
+        List<Integer> docsWithField8 = List.of(0, 1, 3, 4);
+
+        List<Long> dimList6 = List.of(5L, 6L, 7L, 8L);
+        List<Integer> docsWithField6 = List.of(0, 1, 2, 3);
+        List<Long> metricsList21 = List.of(
+            getLongFromDouble(50.0),
+            getLongFromDouble(60.0),
+            getLongFromDouble(70.0),
+            getLongFromDouble(80.0),
+            getLongFromDouble(90.0)
+        );
+        List<Integer> metricsWithField21 = List.of(0, 1, 2, 3, 4);
+        List<Long> metricsList2 = List.of(5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField2 = List.of(0, 1, 2, 3, 4);
+
+        compositeField = getStarTreeFieldWithDateDimension();
+        StarTreeValues starTreeValues = getStarTreeValuesWithDates(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(dimList7, docsWithField7),
+            getSortedNumericMock(dimList5, docsWithField5),
+            getSortedNumericMock(metricsList, metricsWithField),
+            getSortedNumericMock(metricsList1, metricsWithField1),
+            compositeField,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValuesWithDates(
+            getSortedNumericMock(dimList3, docsWithField3),
+            getSortedNumericMock(dimList4, docsWithField4),
+            getSortedNumericMock(dimList8, docsWithField8),
+            getSortedNumericMock(dimList6, docsWithField6),
+            getSortedNumericMock(metricsList2, metricsWithField2),
+            getSortedNumericMock(metricsList21, metricsWithField21),
+            compositeField,
+            "4"
+        );
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, getWriteState(4, writeState.segmentInfo.getId()), mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         [1655287972000, 1655287972000, 1655287972000, 3] | [30.0, 3]
+         [1655288032000, 1655288032000, 1655288032000, 2] | [20.0, 2]
+         [1655288032000, 1655288032000, 1655288032000, 8] | [80.0, 8]
+         [1655288092000, 1655288092000, 1655288092000, 1] | [10.0, 1]
+         [1655288092000, 1655288092000, 1655288092000, 4] | [40.0, 4]
+         [1655288092000, 1655288092000, 1655288092000, 6] | [60.0, 6]
+         [1655288152000, 1655288152000, 1655288152000, 0] | [0.0, 0]
+         [1655288152000, 1655288152000, 1655288152000, 5] | [50.0, 5]
+         [null, null, null, 5] | [50.0, 5]
+         [null, null, null, 7] | [70.0, 7]
+         */
+        int count = 0;
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            assertEquals(starTreeDocument.dimensions[3] * 10.0, (double) starTreeDocument.metrics[1], 0);
+            assertEquals(starTreeDocument.dimensions[3], starTreeDocument.metrics[0]);
+        }
+        assertEquals(10, count);
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        validateStarTree(builder.getRootNode(), 4, 10, builder.getStarTreeDocuments());
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            10,
+            builder.numStarTreeDocs,
+            compositeField.getStarTreeConfig().maxLeafDocs(),
+            Set.of(),
+            getBuildMode(),
+            0,
+            231
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    private StarTreeValues getStarTreeValuesWithDates(
+        SortedNumericDocValues dimList,
+        SortedNumericDocValues dimList2,
+        SortedNumericDocValues dimList4,
+        SortedNumericDocValues dimList3,
+        SortedNumericDocValues metricsList,
+        SortedNumericDocValues metricsList1,
+        StarTreeField sf,
+        String number
+    ) {
+        Map<String, Supplier<StarTreeValuesIterator>> dimDocIdSetIterators = Map.of(
+            "field1_minute",
+            () -> new SortedNumericStarTreeValuesIterator(dimList),
+            "field1_half-hour",
+            () -> new SortedNumericStarTreeValuesIterator(dimList4),
+            "field1_hour",
+            () -> new SortedNumericStarTreeValuesIterator(dimList2),
+            "field3",
+            () -> new SortedNumericStarTreeValuesIterator(dimList3)
+        );
+        Map<String, Supplier<StarTreeValuesIterator>> metricDocIdSetIterators = new LinkedHashMap<>();
+
+        metricDocIdSetIterators.put(
+            fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                sf.getName(),
+                "field2",
+                sf.getMetrics().get(0).getMetrics().get(0).getTypeName()
+            ),
+            () -> new SortedNumericStarTreeValuesIterator(metricsList)
+        );
+        metricDocIdSetIterators.put(
+            fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                sf.getName(),
+                "field2",
+                sf.getMetrics().get(0).getMetrics().get(1).getTypeName()
+            ),
+            () -> new SortedNumericStarTreeValuesIterator(metricsList1)
+        );
+        return new StarTreeValues(sf, null, dimDocIdSetIterators, metricDocIdSetIterators, Map.of(SEGMENT_DOCS_COUNT, number), null);
+    }
+
+    private StarTreeField getStarTreeFieldWithDateDimension() {
+        List<DateTimeUnitRounding> intervals = new ArrayList<>();
+        intervals.add(new DateTimeUnitAdapter(Rounding.DateTimeUnit.MINUTES_OF_HOUR));
+        intervals.add(new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY));
+        intervals.add(DataCubeDateTimeUnit.HALF_HOUR_OF_DAY);
+        Dimension d1 = new DateDimension("field1", intervals, DateFieldMapper.Resolution.MILLISECONDS);
+        Dimension d2 = new NumericDimension("field3");
+        Metric m1 = new Metric("field2", List.of(MetricStat.VALUE_COUNT, MetricStat.SUM));
+        List<Dimension> dims = List.of(d1, d2);
+        List<Metric> metrics = List.of(m1);
+        StarTreeFieldConfiguration c = new StarTreeFieldConfiguration(10, new HashSet<>(), getBuildMode());
+        StarTreeField sf = new StarTreeField("sf", dims, metrics, c);
+        return sf;
+    }
+
     private void validateStarTree(
         InMemoryTreeNode root,
         int totalDimensions,
diff --git a/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
index b415e1e657f7f..c35cf3fc1e591 100644
--- a/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
@@ -506,10 +506,10 @@ public void testCompositeFields() throws Exception {
             .startObject("startree")
             .field("type", "star_tree")
             .startObject("config")
-            .startArray("ordered_dimensions")
-            .startObject()
-            .field("name", "node")
+            .startObject("date_dimension")
+            .field("name", "@timestamp")
             .endObject()
+            .startArray("ordered_dimensions")
             .startObject()
             .field("name", "status")
             .endObject()
@@ -526,8 +526,8 @@ public void testCompositeFields() throws Exception {
             .endObject()
             .endObject()
             .startObject("properties")
-            .startObject("node")
-            .field("type", "integer")
+            .startObject("@timestamp")
+            .field("type", "date")
             .endObject()
             .startObject("status")
             .field("type", "integer")
@@ -565,9 +565,9 @@ public void testCompositeFields() throws Exception {
         StarTreeMapper starTreeMapper = (StarTreeMapper) mapper;
         assertEquals("star_tree", starTreeMapper.fieldType().typeName());
         // Check that field in properties was parsed correctly as well
-        mapper = documentMapper.root().getMapper("node");
+        mapper = documentMapper.root().getMapper("@timestamp");
         assertNotNull(mapper);
-        assertEquals("integer", mapper.typeName());
+        assertEquals("date", mapper.typeName());
 
         FeatureFlags.initializeFeatureFlags(Settings.EMPTY);
     }
diff --git a/server/src/test/java/org/opensearch/index/mapper/StarTreeMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/StarTreeMapperTests.java
index daa9fda7a5a3b..aac460bd5e332 100644
--- a/server/src/test/java/org/opensearch/index/mapper/StarTreeMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/StarTreeMapperTests.java
@@ -18,6 +18,7 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.compositeindex.CompositeIndexSettings;
 import org.opensearch.index.compositeindex.CompositeIndexValidator;
+import org.opensearch.index.compositeindex.datacube.DataCubeDateTimeUnit;
 import org.opensearch.index.compositeindex.datacube.DateDimension;
 import org.opensearch.index.compositeindex.datacube.Dimension;
 import org.opensearch.index.compositeindex.datacube.Metric;
@@ -27,6 +28,8 @@
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitAdapter;
+import org.opensearch.index.compositeindex.datacube.startree.utils.date.DateTimeUnitRounding;
 import org.junit.After;
 import org.junit.Before;
 
@@ -42,6 +45,7 @@
 import static org.opensearch.index.IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING;
 import static org.opensearch.index.compositeindex.CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING;
 import static org.hamcrest.Matchers.containsString;
+import static com.carrotsearch.randomizedtesting.RandomizedTest.getRandom;
 
 /**
  * Tests for {@link StarTreeMapper}.
@@ -74,7 +78,16 @@ public void testValidStarTree() throws IOException {
         for (CompositeMappedFieldType type : compositeFieldTypes) {
             StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
             assertEquals(2, starTreeFieldType.getDimensions().size());
-            assertEquals("node", starTreeFieldType.getDimensions().get(0).getField());
+            assertEquals("@timestamp", starTreeFieldType.getDimensions().get(0).getField());
+            assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+            DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+            List<DateTimeUnitRounding> expectedTimeUnits = Arrays.asList(
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.DAY_OF_MONTH),
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.MONTH_OF_YEAR)
+            );
+            for (int i = 0; i < expectedTimeUnits.size(); i++) {
+                assertEquals(expectedTimeUnits.get(i).shortName(), dateDim.getIntervals().get(i).shortName());
+            }
             assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
             assertEquals(2, starTreeFieldType.getMetrics().size());
             assertEquals("size", starTreeFieldType.getMetrics().get(0).getField());
@@ -85,7 +98,7 @@ public void testValidStarTree() throws IOException {
             assertEquals(100, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
             assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
             assertEquals(
-                new HashSet<>(Arrays.asList("node", "status")),
+                new HashSet<>(Arrays.asList("@timestamp", "status")),
                 starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims()
             );
         }
@@ -130,7 +143,16 @@ public void testMetricsWithJustSum() throws IOException {
         Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
         for (CompositeMappedFieldType type : compositeFieldTypes) {
             StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
-            assertEquals("node", starTreeFieldType.getDimensions().get(0).getField());
+            assertEquals("@timestamp", starTreeFieldType.getDimensions().get(0).getField());
+            assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+            DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+            List<Rounding.DateTimeUnit> expectedTimeUnits = Arrays.asList(
+                Rounding.DateTimeUnit.DAY_OF_MONTH,
+                Rounding.DateTimeUnit.MONTH_OF_YEAR
+            );
+            for (int i = 0; i < expectedTimeUnits.size(); i++) {
+                assertEquals(new DateTimeUnitAdapter(expectedTimeUnits.get(i)), dateDim.getIntervals().get(i));
+            }
             assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
             assertEquals("size", starTreeFieldType.getMetrics().get(0).getField());
 
@@ -140,7 +162,7 @@ public void testMetricsWithJustSum() throws IOException {
             assertEquals(100, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
             assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
             assertEquals(
-                new HashSet<>(Arrays.asList("node", "status")),
+                new HashSet<>(Arrays.asList("@timestamp", "status")),
                 starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims()
             );
         }
@@ -151,7 +173,16 @@ public void testMetricsWithCountAndSum() throws IOException {
         Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
         for (CompositeMappedFieldType type : compositeFieldTypes) {
             StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
-            assertEquals("node", starTreeFieldType.getDimensions().get(0).getField());
+            assertEquals("@timestamp", starTreeFieldType.getDimensions().get(0).getField());
+            assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+            DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+            List<Rounding.DateTimeUnit> expectedTimeUnits = Arrays.asList(
+                Rounding.DateTimeUnit.DAY_OF_MONTH,
+                Rounding.DateTimeUnit.MONTH_OF_YEAR
+            );
+            for (int i = 0; i < expectedTimeUnits.size(); i++) {
+                assertEquals(new DateTimeUnitAdapter(expectedTimeUnits.get(i)), dateDim.getIntervals().get(i));
+            }
             assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
             assertEquals("size", starTreeFieldType.getMetrics().get(0).getField());
 
@@ -166,18 +197,47 @@ public void testMetricsWithCountAndSum() throws IOException {
             assertEquals(100, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
             assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
             assertEquals(
-                new HashSet<>(Arrays.asList("node", "status")),
+                new HashSet<>(Arrays.asList("@timestamp", "status")),
                 starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims()
             );
         }
     }
 
+    public void testValidStarTreeWithNoDateDim() throws IOException {
+        MapperService mapperService = createMapperService(getMinMappingWithDateDims(false, true, true));
+        Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
+        for (CompositeMappedFieldType type : compositeFieldTypes) {
+            StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
+            assertEquals("status", starTreeFieldType.getDimensions().get(0).getField());
+            assertTrue(starTreeFieldType.getDimensions().get(0) instanceof NumericDimension);
+            assertEquals("metric_field", starTreeFieldType.getDimensions().get(1).getField());
+            assertTrue(starTreeFieldType.getDimensions().get(0) instanceof NumericDimension);
+            assertEquals("status", starTreeFieldType.getMetrics().get(0).getField());
+            List<MetricStat> expectedMetrics = Arrays.asList(MetricStat.VALUE_COUNT, MetricStat.SUM, MetricStat.AVG);
+            assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+            assertEquals(10000, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+            assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
+            assertEquals(new HashSet<>(), starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims());
+        }
+    }
+
     public void testValidStarTreeDefaults() throws IOException {
         MapperService mapperService = createMapperService(getMinMapping());
         Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
         for (CompositeMappedFieldType type : compositeFieldTypes) {
             StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
-            assertEquals("node", starTreeFieldType.getDimensions().get(0).getField());
+            assertEquals("@timestamp", starTreeFieldType.getDimensions().get(0).getField());
+            assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+            DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+            List<String> expectedDimensionFields = Arrays.asList("@timestamp_minute", "@timestamp_half-hour");
+            assertEquals(expectedDimensionFields, dateDim.getSubDimensionNames());
+            List<DateTimeUnitRounding> expectedTimeUnits = Arrays.asList(
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.MINUTES_OF_HOUR),
+                DataCubeDateTimeUnit.HALF_HOUR_OF_DAY
+            );
+            for (int i = 0; i < expectedTimeUnits.size(); i++) {
+                assertEquals(expectedTimeUnits.get(i).shortName(), dateDim.getIntervals().get(i).shortName());
+            }
             assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
             assertEquals(3, starTreeFieldType.getMetrics().size());
             assertEquals("status", starTreeFieldType.getMetrics().get(0).getField());
@@ -196,6 +256,56 @@ public void testValidStarTreeDefaults() throws IOException {
         }
     }
 
+    public void testValidStarTreeDateDims() throws IOException {
+        MapperService mapperService = createMapperService(getMinMappingWithDateDims(false, false, false));
+        Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
+        for (CompositeMappedFieldType type : compositeFieldTypes) {
+            StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
+            assertEquals("@timestamp", starTreeFieldType.getDimensions().get(0).getField());
+            assertTrue(starTreeFieldType.getDimensions().get(0) instanceof DateDimension);
+            DateDimension dateDim = (DateDimension) starTreeFieldType.getDimensions().get(0);
+            List<String> expectedDimensionFields = Arrays.asList("@timestamp_half-hour", "@timestamp_week", "@timestamp_month");
+            assertEquals(expectedDimensionFields, dateDim.getSubDimensionNames());
+            List<DateTimeUnitRounding> expectedTimeUnits = Arrays.asList(
+                DataCubeDateTimeUnit.HALF_HOUR_OF_DAY,
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.WEEK_OF_WEEKYEAR),
+                new DateTimeUnitAdapter(Rounding.DateTimeUnit.MONTH_OF_YEAR)
+            );
+            for (int i = 0; i < expectedTimeUnits.size(); i++) {
+                assertEquals(expectedTimeUnits.get(i).shortName(), dateDim.getSortedCalendarIntervals().get(i).shortName());
+            }
+            assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
+            assertEquals("status", starTreeFieldType.getMetrics().get(0).getField());
+            List<MetricStat> expectedMetrics = Arrays.asList(MetricStat.VALUE_COUNT, MetricStat.SUM, MetricStat.AVG);
+            assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+            assertEquals(10000, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+            assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
+            assertEquals(Collections.emptySet(), starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims());
+        }
+    }
+
+    public void testInValidStarTreeMinDims() throws IOException {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getMinMappingWithDateDims(false, true, false))
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: Atleast two dimensions are required to build star tree index field [startree]",
+            ex.getMessage()
+        );
+    }
+
+    public void testInvalidStarTreeDateDims() throws IOException {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getMinMappingWithDateDims(true, false, false))
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: At most [3] calendar intervals are allowed in dimension [@timestamp]",
+            ex.getMessage()
+        );
+    }
+
     public void testInvalidDim() {
         MapperParsingException ex = expectThrows(
             MapperParsingException.class,
@@ -215,7 +325,7 @@ public void testInvalidMetric() {
     public void testNoMetrics() {
         MapperParsingException ex = expectThrows(
             MapperParsingException.class,
-            () -> createMapperService(getMinMapping(false, true, false, false))
+            () -> createMapperService(getMinMapping(false, true, false, false, false))
         );
         assertThat(
             ex.getMessage(),
@@ -226,7 +336,7 @@ public void testNoMetrics() {
     public void testInvalidParam() {
         MapperParsingException ex = expectThrows(
             MapperParsingException.class,
-            () -> createMapperService(getInvalidMapping(false, false, false, false, true, false))
+            () -> createMapperService(getInvalidMapping(false, false, false, false, true, false, false))
         );
         assertEquals(
             "Failed to parse mapping [_doc]: Star tree mapping definition has unsupported parameters:  [invalid : {invalid=invalid}]",
@@ -237,7 +347,7 @@ public void testInvalidParam() {
     public void testNoDims() {
         MapperParsingException ex = expectThrows(
             MapperParsingException.class,
-            () -> createMapperService(getMinMapping(true, false, false, false))
+            () -> createMapperService(getMinMapping(true, false, false, false, false))
         );
         assertThat(
             ex.getMessage(),
@@ -245,18 +355,26 @@ public void testNoDims() {
         );
     }
 
+    public void testMissingDateDims() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getMinMapping(false, false, false, false, true))
+        );
+        assertThat(ex.getMessage(), containsString("Failed to parse mapping [_doc]: unknown date dimension field [@timestamp]"));
+    }
+
     public void testMissingDims() {
         MapperParsingException ex = expectThrows(
             MapperParsingException.class,
-            () -> createMapperService(getMinMapping(false, false, true, false))
+            () -> createMapperService(getMinMapping(false, false, true, false, false))
         );
-        assertThat(ex.getMessage(), containsString("Failed to parse mapping [_doc]: unknown dimension field [node]"));
+        assertThat(ex.getMessage(), containsString("Failed to parse mapping [_doc]: unknown dimension field [status]"));
     }
 
     public void testMissingMetrics() {
         MapperParsingException ex = expectThrows(
             MapperParsingException.class,
-            () -> createMapperService(getMinMapping(false, false, false, true))
+            () -> createMapperService(getMinMapping(false, false, false, true, false))
         );
         assertThat(ex.getMessage(), containsString("Failed to parse mapping [_doc]: unknown metric field [metric_field]"));
     }
@@ -275,7 +393,7 @@ public void testInvalidMetricType() {
     public void testInvalidMetricTypeWithDocCount() {
         MapperParsingException ex = expectThrows(
             MapperParsingException.class,
-            () -> createMapperService(getInvalidMapping(false, false, false, false, false, true))
+            () -> createMapperService(getInvalidMapping(false, false, false, false, false, true, false))
         );
         assertEquals("Failed to parse mapping [_doc]: Invalid metric stat: _doc_count", ex.getMessage());
     }
@@ -286,7 +404,18 @@ public void testInvalidDimType() {
             () -> createMapperService(getInvalidMapping(false, false, true, false))
         );
         assertEquals(
-            "Failed to parse mapping [_doc]: unsupported field type associated with dimension [node] as part of star tree field [startree]",
+            "Failed to parse mapping [_doc]: unsupported field type associated with dimension [status] as part of star tree field [startree]",
+            ex.getMessage()
+        );
+    }
+
+    public void testInvalidDateDimType() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getInvalidMapping(false, false, true, false, false, false, true))
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: date_dimension [@timestamp] should be of type date for star tree field [startree]",
             ex.getMessage()
         );
     }
@@ -356,17 +485,17 @@ public void testMetric() {
     }
 
     public void testDimensions() {
-        List<Rounding.DateTimeUnit> d1CalendarIntervals = new ArrayList<>();
-        d1CalendarIntervals.add(Rounding.DateTimeUnit.HOUR_OF_DAY);
-        DateDimension d1 = new DateDimension("name", d1CalendarIntervals);
-        DateDimension d2 = new DateDimension("name", d1CalendarIntervals);
+        List<DateTimeUnitRounding> d1CalendarIntervals = new ArrayList<>();
+        d1CalendarIntervals.add(new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY));
+        DateDimension d1 = new DateDimension("name", d1CalendarIntervals, DateFieldMapper.Resolution.MILLISECONDS);
+        DateDimension d2 = new DateDimension("name", d1CalendarIntervals, DateFieldMapper.Resolution.MILLISECONDS);
         assertEquals(d1, d2);
-        d2 = new DateDimension("name1", d1CalendarIntervals);
+        d2 = new DateDimension("name1", d1CalendarIntervals, DateFieldMapper.Resolution.MILLISECONDS);
         assertNotEquals(d1, d2);
-        List<Rounding.DateTimeUnit> d2CalendarIntervals = new ArrayList<>();
-        d2CalendarIntervals.add(Rounding.DateTimeUnit.HOUR_OF_DAY);
-        d2CalendarIntervals.add(Rounding.DateTimeUnit.HOUR_OF_DAY);
-        d2 = new DateDimension("name", d2CalendarIntervals);
+        List<DateTimeUnitRounding> d2CalendarIntervals = new ArrayList<>();
+        d2CalendarIntervals.add(new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY));
+        d2CalendarIntervals.add(new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY));
+        d2 = new DateDimension("name", d2CalendarIntervals, DateFieldMapper.Resolution.MILLISECONDS);
         assertNotEquals(d1, d2);
         NumericDimension n1 = new NumericDimension("name");
         NumericDimension n2 = new NumericDimension("name");
@@ -387,9 +516,9 @@ public void testStarTreeField() {
         List<MetricStat> m1 = new ArrayList<>();
         m1.add(MetricStat.MAX);
         Metric metric1 = new Metric("name", m1);
-        List<Rounding.DateTimeUnit> d1CalendarIntervals = new ArrayList<>();
-        d1CalendarIntervals.add(Rounding.DateTimeUnit.HOUR_OF_DAY);
-        DateDimension d1 = new DateDimension("name", d1CalendarIntervals);
+        List<DateTimeUnitRounding> d1CalendarIntervals = new ArrayList<>();
+        d1CalendarIntervals.add(new DateTimeUnitAdapter(Rounding.DateTimeUnit.HOUR_OF_DAY));
+        DateDimension d1 = new DateDimension("name", d1CalendarIntervals, DateFieldMapper.Resolution.MILLISECONDS);
         NumericDimension n1 = new NumericDimension("numeric");
         NumericDimension n2 = new NumericDimension("name1");
 
@@ -483,7 +612,7 @@ public void testValidations() throws IOException {
             )
         );
         assertEquals(
-            "Aggregations not supported for the dimension field [node] with field type [integer] as part of star tree field",
+            "Aggregations not supported for the dimension field [@timestamp] with field type [date] as part of star tree field",
             ex.getMessage()
         );
 
@@ -506,14 +635,18 @@ private XContentBuilder getExpandedMappingWithJustAvg(String dim, String metric)
             b.field("max_leaf_docs", 100);
             b.startArray("skip_star_node_creation_for_dimensions");
             {
-                b.value("node");
+                b.value("@timestamp");
                 b.value("status");
             }
             b.endArray();
-            b.startArray("ordered_dimensions");
-            b.startObject();
-            b.field("name", "node");
+            b.startObject("date_dimension");
+            b.field("name", "@timestamp");
+            b.startArray("calendar_intervals");
+            b.value("day");
+            b.value("month");
+            b.endArray();
             b.endObject();
+            b.startArray("ordered_dimensions");
             b.startObject();
             b.field("name", dim);
             b.endObject();
@@ -530,8 +663,8 @@ private XContentBuilder getExpandedMappingWithJustAvg(String dim, String metric)
             b.endObject();
             b.endObject();
             b.startObject("properties");
-            b.startObject("node");
-            b.field("type", "integer");
+            b.startObject("@timestamp");
+            b.field("type", "date");
             b.endObject();
             b.startObject("status");
             b.field("type", "integer");
@@ -551,10 +684,10 @@ private XContentBuilder getMappingWithDuplicateFields(boolean isDuplicateDim, bo
                 .startObject("startree-1")
                 .field("type", "star_tree")
                 .startObject("config")
-                .startArray("ordered_dimensions")
-                .startObject()
-                .field("name", "node")
+                .startObject("date_dimension")
+                .field("name", "timestamp")
                 .endObject()
+                .startArray("ordered_dimensions")
                 .startObject()
                 .field("name", "numeric_dv")
                 .endObject()
@@ -574,8 +707,8 @@ private XContentBuilder getMappingWithDuplicateFields(boolean isDuplicateDim, bo
                 .endObject()
                 .endObject()
                 .startObject("properties")
-                .startObject("node")
-                .field("type", "integer")
+                .startObject("timestamp")
+                .field("type", "date")
                 .endObject()
                 .startObject("numeric_dv")
                 .field("type", "integer")
@@ -602,14 +735,18 @@ private XContentBuilder getExpandedMappingWithJustSum(String dim, String metric)
             b.field("max_leaf_docs", 100);
             b.startArray("skip_star_node_creation_for_dimensions");
             {
-                b.value("node");
+                b.value("@timestamp");
                 b.value("status");
             }
             b.endArray();
-            b.startArray("ordered_dimensions");
-            b.startObject();
-            b.field("name", "node");
+            b.startObject("date_dimension");
+            b.field("name", "@timestamp");
+            b.startArray("calendar_intervals");
+            b.value("day");
+            b.value("month");
+            b.endArray();
             b.endObject();
+            b.startArray("ordered_dimensions");
             b.startObject();
             b.field("name", dim);
             b.endObject();
@@ -626,8 +763,8 @@ private XContentBuilder getExpandedMappingWithJustSum(String dim, String metric)
             b.endObject();
             b.endObject();
             b.startObject("properties");
-            b.startObject("node");
-            b.field("type", "integer");
+            b.startObject("@timestamp");
+            b.field("type", "date");
             b.endObject();
             b.startObject("status");
             b.field("type", "integer");
@@ -648,14 +785,18 @@ private XContentBuilder getExpandedMappingWithSumAndCount(String dim, String met
             b.field("max_leaf_docs", 100);
             b.startArray("skip_star_node_creation_for_dimensions");
             {
-                b.value("node");
+                b.value("@timestamp");
                 b.value("status");
             }
             b.endArray();
-            b.startArray("ordered_dimensions");
-            b.startObject();
-            b.field("name", "node");
+            b.startObject("date_dimension");
+            b.field("name", "@timestamp");
+            b.startArray("calendar_intervals");
+            b.value("day");
+            b.value("month");
+            b.endArray();
             b.endObject();
+            b.startArray("ordered_dimensions");
             b.startObject();
             b.field("name", dim);
             b.endObject();
@@ -673,8 +814,8 @@ private XContentBuilder getExpandedMappingWithSumAndCount(String dim, String met
             b.endObject();
             b.endObject();
             b.startObject("properties");
-            b.startObject("node");
-            b.field("type", "integer");
+            b.startObject("@timestamp");
+            b.field("type", "date");
             b.endObject();
             b.startObject("status");
             b.field("type", "integer");
@@ -687,21 +828,95 @@ private XContentBuilder getExpandedMappingWithSumAndCount(String dim, String met
     }
 
     private XContentBuilder getMinMapping() throws IOException {
-        return getMinMapping(false, false, false, false);
+        return getMinMapping(false, false, false, false, false);
     }
 
-    private XContentBuilder getMinMapping(boolean isEmptyDims, boolean isEmptyMetrics, boolean missingDim, boolean missingMetric)
+    private XContentBuilder getMinMappingWithDateDims(boolean calendarIntervalsExceeded, boolean dateDimsAbsent, boolean additionalDim)
         throws IOException {
         return topMapping(b -> {
             b.startObject("composite");
             b.startObject("startree");
+
             b.field("type", "star_tree");
+
             b.startObject("config");
-            if (!isEmptyDims) {
-                b.startArray("ordered_dimensions");
+            if (!dateDimsAbsent) {
+                b.startObject("date_dimension");
+                b.field("name", "@timestamp");
+                b.startArray("calendar_intervals");
+                b.value(getRandom().nextBoolean() ? "week" : "1w");
+                if (calendarIntervalsExceeded) {
+                    b.value(getRandom().nextBoolean() ? "day" : "1d");
+                    b.value(getRandom().nextBoolean() ? "second" : "1s");
+                    b.value(getRandom().nextBoolean() ? "hour" : "1h");
+                    b.value(getRandom().nextBoolean() ? "minute" : "1m");
+                    b.value(getRandom().nextBoolean() ? "year" : "1y");
+                    b.value(getRandom().nextBoolean() ? "quarter-hour" : "15m");
+                }
+                b.value(getRandom().nextBoolean() ? "month" : "1M");
+                b.value(getRandom().nextBoolean() ? "half-hour" : "30m");
+                b.endArray();
+                b.endObject();
+            }
+            b.startArray("ordered_dimensions");
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            if (additionalDim) {
                 b.startObject();
-                b.field("name", "node");
+                b.field("name", "metric_field");
                 b.endObject();
+            }
+            b.endArray();
+
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.startObject();
+            b.field("name", "metric_field");
+            b.endObject();
+            b.endArray();
+
+            b.endObject();
+
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+
+            b.startObject("@timestamp");
+            b.field("type", "date");
+            b.endObject();
+
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+
+            b.startObject("metric_field");
+            b.field("type", "integer");
+            b.endObject();
+
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder getMinMapping(
+        boolean isEmptyDims,
+        boolean isEmptyMetrics,
+        boolean missingDim,
+        boolean missingMetric,
+        boolean missingDateDim
+    ) throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+            if (!isEmptyDims) {
+                b.startObject("date_dimension");
+                b.field("name", "@timestamp");
+                b.endObject();
+                b.startArray("ordered_dimensions");
                 b.startObject();
                 b.field("name", "status");
                 b.endObject();
@@ -721,14 +936,16 @@ private XContentBuilder getMinMapping(boolean isEmptyDims, boolean isEmptyMetric
             b.endObject();
             b.endObject();
             b.startObject("properties");
+            if (!missingDateDim) {
+                b.startObject("@timestamp");
+                b.field("type", "date");
+                b.endObject();
+            }
             if (!missingDim) {
-                b.startObject("node");
+                b.startObject("status");
                 b.field("type", "integer");
                 b.endObject();
             }
-            b.startObject("status");
-            b.field("type", "integer");
-            b.endObject();
             if (!missingMetric) {
                 b.startObject("metric_field");
                 b.field("type", "integer");
@@ -812,14 +1029,14 @@ private XContentBuilder getInvalidMapping(
         boolean invalidDimType,
         boolean invalidMetricType,
         boolean invalidParam,
-        boolean invalidDocCountMetricType
+        boolean invalidDocCountMetricType,
+        boolean invalidDate
     ) throws IOException {
         return topMapping(b -> {
             b.startObject("composite");
             b.startObject("startree");
             b.field("type", "star_tree");
             b.startObject("config");
-
             b.startArray("skip_star_node_creation_for_dimensions");
             {
                 if (invalidSkipDims) {
@@ -828,6 +1045,9 @@ private XContentBuilder getInvalidMapping(
                 b.value("status");
             }
             b.endArray();
+            b.startObject("date_dimension");
+            b.field("name", "@timestamp");
+            b.endObject();
             if (invalidParam) {
                 b.startObject("invalid");
                 b.field("invalid", "invalid");
@@ -836,12 +1056,9 @@ private XContentBuilder getInvalidMapping(
             b.startArray("ordered_dimensions");
             if (!singleDim) {
                 b.startObject();
-                b.field("name", "node");
+                b.field("name", "status");
                 b.endObject();
             }
-            b.startObject();
-            b.field("name", "status");
-            b.endObject();
             b.endArray();
             b.startArray("metrics");
             b.startObject();
@@ -861,16 +1078,20 @@ private XContentBuilder getInvalidMapping(
             b.endObject();
             b.endObject();
             b.startObject("properties");
-            b.startObject("node");
-            if (!invalidDimType) {
-                b.field("type", "integer");
+            b.startObject("@timestamp");
+            if (!invalidDate) {
+                b.field("type", "date");
             } else {
                 b.field("type", "keyword");
             }
             b.endObject();
 
             b.startObject("status");
-            b.field("type", "integer");
+            if (!invalidDimType) {
+                b.field("type", "integer");
+            } else {
+                b.field("type", "keyword");
+            }
             b.endObject();
             b.startObject("metric_field");
             if (invalidMetricType) {
@@ -903,15 +1124,15 @@ private XContentBuilder getInvalidMappingWithDv(
                 b.value("status");
             }
             b.endArray();
+            b.startObject("date_dimension");
+            b.field("name", "@timestamp");
+            b.endObject();
             b.startArray("ordered_dimensions");
             if (!singleDim) {
                 b.startObject();
-                b.field("name", "node");
+                b.field("name", "status");
                 b.endObject();
             }
-            b.startObject();
-            b.field("name", "status");
-            b.endObject();
             b.endArray();
             b.startArray("metrics");
             b.startObject();
@@ -925,12 +1146,12 @@ private XContentBuilder getInvalidMappingWithDv(
             b.endObject();
             b.endObject();
             b.startObject("properties");
-            b.startObject("node");
+            b.startObject("@timestamp");
             if (!invalidDimType) {
-                b.field("type", "integer");
+                b.field("type", "date");
                 b.field("doc_values", "true");
             } else {
-                b.field("type", "integer");
+                b.field("type", "date");
                 b.field("doc_values", "false");
             }
             b.endObject();
@@ -953,7 +1174,7 @@ private XContentBuilder getInvalidMappingWithDv(
 
     private XContentBuilder getInvalidMapping(boolean singleDim, boolean invalidSkipDims, boolean invalidDimType, boolean invalidMetricType)
         throws IOException {
-        return getInvalidMapping(singleDim, invalidSkipDims, invalidDimType, invalidMetricType, false, false);
+        return getInvalidMapping(singleDim, invalidSkipDims, invalidDimType, invalidMetricType, false, false, false);
     }
 
     protected boolean supportsOrIgnoresBoost() {