@openui5/sap.ui.core 1.120.1 → 1.120.3

package/src/sap/ui/model/odata/v4/lib/_AggregationCache.js

@@ -1,6 +1,6 @@
 /*!
  * OpenUI5
- * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
  * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
  */
 
@@ -13,9 +13,10 @@ sap.ui.define([
 	"./_Helper",
 	"./_MinMaxHelper",
 	"sap/base/Log",
-	"sap/ui/base/SyncPromise"
+	"sap/ui/base/SyncPromise",
+	"sap/ui/model/odata/ODataUtils"
 ], function (_AggregationHelper, _Cache, _ConcatHelper, _GroupLock, _Helper, _MinMaxHelper, Log,
-		SyncPromise) {
+		SyncPromise, ODataUtils) {
 	"use strict";
 
 	//*********************************************************************************************
@@ -174,7 +175,7 @@ sap.ui.define([
 			iIndex = _Cache.getElementIndex(this.aElements, sPredicate, iIndex);
 			// remove in parent cache
 			const iIndexInParentCache = oParentCache.removeElement(
-				_Helper.getPrivateAnnotation(oElement, "index", 0), sPredicate);
+				_Helper.getPrivateAnnotation(oElement, "rank", 0), sPredicate);
 			// remove the descendants in the parent cache (if any)
 			const iDescendants = _Helper.getPrivateAnnotation(oElement, "descendants", 0);
 			for (let i = 0; i < iDescendants; i += 1) {
@@ -187,9 +188,7 @@ sap.ui.define([
 				// make parent a leaf (the direct predecessor)
 				this.makeLeaf(this.aElements[iIndex - 1]);
 			}
-			if (!("@$ui5.context.isTransient" in oElement)) {
-				this.shiftIndex(iIndex, -iOffset);
-			}
+			this.shiftRank(iIndex, -iOffset);
 			// remove in this cache
 			this.removeElement(iIndex, sPredicate);
 			// notify caller
@@ -208,8 +207,9 @@ sap.ui.define([
 	 *   The group level cache which the given elements have been read from; omit it only for grand
 	 *   totals or separate subtotals
 	 * @param {number} [iStart]
-	 *   The $skip index of the first given element within the cache's collection; omit it only if
-	 *   no group level cache is given or for a single created element (where it is always unknown)
+	 *   The rank (aka. $skip index) of the first given element within the cache's collection; omit
+	 *   it only if no group level cache is given or for a single created element (where it may be
+	 *   unknown)
 	 * @throws {Error}
 	 *   In case an unexpected element or placeholder would be overwritten, if the given offset is
 	 *   negative, if a resulting array index is out of bounds, in case of a duplicate predicate, or
@@ -268,9 +268,9 @@ sap.ui.define([
 			}
 
 			if (sTransientPredicate) { // created
-				iStart -= 1; // "shift" index of non-created elements behind this one
+				iStart -= 1; // "shift" rank of non-created elements behind this one
 			} else {
-				_Helper.setPrivateAnnotation(oElement, "index", iStart + i);
+				_Helper.setPrivateAnnotation(oElement, "rank", iStart + i);
 			}
 		}
 
@@ -309,7 +309,7 @@ sap.ui.define([
 			} else if (iCandidateLevel < iLevel) {
 				if (!bInitialPlaceholderFound || this.isAncestorOf(iCandidateIndex, iIndex)) {
 					const iCount
-						= _Helper.getPrivateAnnotation(oCandidate, "descendants") + iOffset;
+						= _Helper.getPrivateAnnotation(oCandidate, "descendants", 0) + iOffset;
 					_Helper.setPrivateAnnotation(oCandidate, "descendants", iCount);
 					if (iCount === 0) {
 						this.makeLeaf(oCandidate);
@@ -395,7 +395,7 @@ sap.ui.define([
 				_Helper.getPrivateAnnotation(aElements[i], "transientPredicate")];
 		}
 		const aSpliced = aElements.splice(iIndex + 1, iCount);
-		aSpliced.$index = _Helper.getPrivateAnnotation(oGroupNode, "index");
+		aSpliced.$rank = _Helper.getPrivateAnnotation(oGroupNode, "rank");
 		_Helper.setPrivateAnnotation(oGroupNode, "spliced", aSpliced);
 		aElements.$count -= iCount;
 
@@ -420,8 +420,8 @@ sap.ui.define([
 		let iGroupNodeLevel = oGroupNode["@$ui5.node.level"];
 		let iDescendants = _Helper.getPrivateAnnotation(oGroupNode, "descendants");
 		if (iDescendants) { // => this.oAggregation.expandTo > 1
-			// Note: "descendants" refers to LimitedDescendantCountProperty and counts descendants
-			// within "top pyramid" only!
+			// Note: "descendants" refers to LimitedDescendantCount and counts descendants within
+			// "top pyramid" only!
 			iGroupNodeLevel = this.oAggregation.expandTo;
 		}
 		const aElements = this.aElements;
@@ -490,6 +490,10 @@ sap.ui.define([
 		if (oParentNode?.["@$ui5.node.isExpanded"] === false) {
 			throw new Error("Unsupported collapsed parent: " + sParentPath);
 		}
+		if (oParentNode && oParentNode["@$ui5.node.isExpanded"] === undefined) {
+			_Helper.updateAll(this.mChangeListeners, sParentPredicate, oParentNode,
+				{"@$ui5.node.isExpanded" : true}); // not a leaf anymore
+		}
 
 		const iLevel = oParentNode
 			? oParentNode["@$ui5.node.level"] + 1
@@ -501,8 +505,6 @@ sap.ui.define([
 			oCache = this.createGroupLevelCache(oParentNode);
 			oCache.setEmpty();
 			_Helper.setPrivateAnnotation(oParentNode, "cache", oCache);
-			_Helper.updateAll(this.mChangeListeners, sParentPredicate, oParentNode,
-				{"@$ui5.node.isExpanded" : true}); // not a leaf anymore
 		}
 
 		const iIndex = aElements.indexOf(oParentNode) + 1; // 0 w/o oParentNode :-)
@@ -512,8 +514,7 @@ sap.ui.define([
 					this.adjustDescendantCount(oEntityData, iIndex, -1);
 				}
 				aElements.$count -= 1;
-				delete aElements.$byPredicate[
-					_Helper.getPrivateAnnotation(oEntityData, "transientPredicate")];
+				delete aElements.$byPredicate[sTransientPredicate];
 				aElements.splice(iIndex, 1);
 			});
 
@@ -525,18 +526,30 @@ sap.ui.define([
 		oEntityData["@$ui5.node.level"] = iLevel; // do not send via POST!
 
 		aElements.splice(iIndex, 0, null); // create a gap
-		this.addElements(oEntityData, iIndex, oCache); // $skip index is undefined!
+		this.addElements(oEntityData, iIndex, oCache); // rank is undefined!
 		aElements.$count += 1;
 		if (oCache === this.oFirstLevel) {
 			this.adjustDescendantCount(oEntityData, iIndex, +1);
 		}
 
-		return oPromise.then(function () {
+		return oPromise.then(async () => {
 			aElements.$byPredicate[_Helper.getPrivateAnnotation(oEntityData, "predicate")]
 				= oEntityData;
 			// Note: #calculateKeyPredicateRH doesn't know better :-(
 			oEntityData["@$ui5.node.level"] = iLevel;
 
+			if (this.oAggregation.expandTo >= 999) { // "expand all"
+				const iRank = await this.requestRank(oEntityData, oGroupLock.getUnlockedCopy());
+
+				this.oFirstLevel.removeElement(0, sTransientPredicate);
+				_Helper.deletePrivateAnnotation(oEntityData, "transientPredicate");
+				this.oFirstLevel.restoreElement(iRank, oEntityData);
+
+				delete this.aElements.$byPredicate[sTransientPredicate];
+				_Helper.setPrivateAnnotation(oEntityData, "rank", iRank);
+				this.shiftRank(iIndex, +1);
+			}
+
 			return oEntityData;
 		});
 	};
@@ -639,15 +652,19 @@ sap.ui.define([
 			iCount = aSpliced.length;
 			this.aElements.$count = aOldElements.$count + iCount;
 			const iLevelDiff = oGroupNode["@$ui5.node.level"] + 1 - aSpliced[0]["@$ui5.node.level"];
-			const iIndexDiff = _Helper.getPrivateAnnotation(oGroupNode, "index") - aSpliced.$index;
+			const iRankDiff = _Helper.getPrivateAnnotation(oGroupNode, "rank") - aSpliced.$rank;
 			aSpliced.forEach(function (oElement) {
 				var sPredicate = _Helper.getPrivateAnnotation(oElement, "predicate");
 
-				oElement["@$ui5.node.level"] += iLevelDiff;
+				if (oElement["@$ui5.node.level"]) {
+					// Note: level 0 is used for initial placeholders of 1st level cache in case
+					// expandTo > 1
+					oElement["@$ui5.node.level"] += iLevelDiff;
+				}
 				if (_Helper.getPrivateAnnotation(oElement, "parent") === that.oFirstLevel) {
-					const iIndex = _Helper.getPrivateAnnotation(oElement, "index");
-					if (iIndex !== undefined) {
-						_Helper.setPrivateAnnotation(oElement, "index", iIndex + iIndexDiff);
+					const iRank = _Helper.getPrivateAnnotation(oElement, "rank");
+					if (iRank !== undefined) {
+						_Helper.setPrivateAnnotation(oElement, "rank", iRank + iRankDiff);
 					}
 				}
 				if (!_Helper.hasPrivateAnnotation(oElement, "placeholder")) {
@@ -748,6 +765,45 @@ sap.ui.define([
 		});
 	};
 
+	/**
+	 * Returns a promise to be resolved with an OData object for the requested parent node.
+	 *
+	 * @param {number} iIndex
+	 *   The index of the child node
+	 * @param {sap.ui.model.odata.v4.lib._GroupLock} oGroupLock
+	 *   A lock for the group to associate the requests with
+	 * @returns {sap.ui.base.SyncPromise}
+	 *   A promise to be resolved with the requested data of the parent.
+	 *
+	 * @public
+	 */
+	_AggregationCache.prototype.fetchParent = function (iIndex, oGroupLock) {
+		const sFilter = _Helper.getKeyFilter(this.aElements[iIndex], this.oAggregation.$metaPath,
+			this.getTypes());
+		const mQueryOptions = Object.assign({}, this.mQueryOptions);
+
+		mQueryOptions.$apply = "ancestors($root" + this.oAggregation.$path
+			+ "," + this.oAggregation.hierarchyQualifier + "," + this.oAggregation.$NodeProperty
+			+ ",filter(" + sFilter + "),1)";
+
+		const sQueryString = this.sResourcePath
+			+ this.oRequestor.buildQueryString(/*sMetaPath*/null, mQueryOptions);
+
+		return SyncPromise.all([
+			this.oRequestor.request("GET", sQueryString, oGroupLock),
+			this.fetchTypes()
+		]).then((aResults) => {
+			const oParent = aResults[0].value[0];
+			this.visitResponse(oParent, aResults[1],
+				_Helper.getMetaPath(_Helper.buildPath(this.sMetaPath, "")));
+
+			this.aElements.$byPredicate[_Helper.getPrivateAnnotation(oParent, "predicate")]
+				= oParent;
+
+			return oParent;
+		});
+	};
+
 	/**
 	 * Returns a promise to be resolved with an OData object for the requested data.
 	 *
@@ -865,16 +921,13 @@ sap.ui.define([
 	};
 
 	/**
-	 * Returns the index of a parent node
+	 * Returns the index of a parent node.
 	 *
 	 * @param {number} iIndex
 	 *   The index of the child node
-	 * @returns {number|null}
+	 * @returns {number|undefined}
 	 *   The parent node's index, or -1 if the given node is a root node and thus has
-	 *   no parent
-	 * @throws {Error}
-	 *   If the index of a parent cannot be found
-	 *
+	 *   no parent, or <code>undefined</code> if the parent node hasn't been read yet
 	 *
 	 * @public
 	 */
@@ -885,13 +938,22 @@ sap.ui.define([
 			return -1; // a root has no parent
 		}
 
-		for (; iIndex >= 0; iIndex -= 1) {
-			if (this.aElements[iIndex]["@$ui5.node.level"] < iLevel) {
-				return iIndex;
+		let bInitialPlaceholderFound = false;
+		for (let i = iIndex; i >= 0; i -= 1) {
+			const oCandidate = this.aElements[i];
+			const iCandidateLevel = oCandidate["@$ui5.node.level"];
+
+			if (iCandidateLevel === 0) {
+				bInitialPlaceholderFound = true;
+			} else if (iCandidateLevel < iLevel) {
+				if (iCandidateLevel === iLevel - 1
+						&& (!bInitialPlaceholderFound || this.isAncestorOf(i, iIndex))) {
+					return i;
+				}
+				break; // missed the parent
 			}
 		}
-
-		throw new Error("Unexpected error");
+		// return undefined;
 	};
 
 	/**
@@ -996,13 +1058,13 @@ sap.ui.define([
 	/**
 	 * Moves the (child) node with the given path to the parent node with the given path by sending
 	 * a PATCH request for "<parent navigation>@odata.bind". The (child) node may be a leaf or a
-	 * collapsed node, but not expanded!
+	 * collapsed node, but not expanded! Omitting a new parent turns the child into a root.
 	 *
 	 * @param {sap.ui.model.odata.v4.lib._GroupLock} oGroupLock
 	 *   A lock for the group to associate the requests with
 	 * @param {string} sChildPath
 	 *   The (child) node's path relative to the cache
-	 * @param {string} sParentPath
+	 * @param {string} [sParentPath=null]
 	 *   The parent node's path relative to the cache
 	 * @returns {sap.ui.base.SyncPromise<number>}
 	 *   A promise which is resolved with the number of child nodes added (normally one, but maybe
@@ -1011,20 +1073,24 @@ sap.ui.define([
 	 *
 	 * @public
 	 */
-	_AggregationCache.prototype.move = function (oGroupLock, sChildPath, sParentPath) {
+	_AggregationCache.prototype.move = function (oGroupLock, sChildPath, sParentPath = null) {
 		const sTransientPredicate = "($uid=" + _Helper.uid() + ")";
 
 		const sChildPredicate = sChildPath.slice(sChildPath.indexOf("("));
 		const oChildNode = this.aElements.$byPredicate[sChildPredicate];
-		const sParentPredicate = sParentPath.slice(sParentPath.indexOf("("));
+		const sParentPredicate = sParentPath?.slice(sParentPath.indexOf("("));
 		const oParentNode = this.aElements.$byPredicate[sParentPredicate];
 
 		let oReadPromise;
-		let oCache = _Helper.getPrivateAnnotation(oParentNode, "cache");
-		if (!oCache && oParentNode["@$ui5.node.isExpanded"] === false) {
+		let oCache = oParentNode
+			? _Helper.getPrivateAnnotation(oParentNode, "cache")
+			: this.oFirstLevel;
+		if (this.oAggregation.expandTo > 1) { // "expand all": GET LimitedRank
+			oReadPromise = this.requestRank(oChildNode, oGroupLock.getUnlockedCopy());
+		} else if (!oCache && oParentNode["@$ui5.node.isExpanded"] === false) {
 			oCache = this.createGroupLevelCache(oParentNode);
 			// @see #getExclusiveFilter
-			oCache.restoreElement(undefined, 0, oChildNode, "", undefined, sTransientPredicate);
+			oCache.restoreElement(0, oChildNode, undefined, sTransientPredicate);
 			// prefetch from the group level cache
 			oReadPromise = oCache.read(0, this.iReadLength, 0, oGroupLock.getUnlockedCopy());
 		}
@@ -1036,17 +1102,48 @@ sap.ui.define([
 				}, {[this.oAggregation.$ParentNavigationProperty + "@odata.bind"] : sParentPath},
 				/*fnSubmit*/null, function fnCancel() { /*nothing to do*/ }),
 			oReadPromise
-		]).then(([oPatchResult, _oReadResult]) => {
+		]).then(([oPatchResult, iPreorderRank]) => {
+			const updateChildNode = () => {
+				// update the cache with the PATCH response (Note: "@odata.etag" is optional!)
+				_Helper.updateExisting(this.mChangeListeners, sChildPredicate, oChildNode, {
+					"@odata.etag" : oPatchResult["@odata.etag"],
+					"@$ui5.node.level" : oParentNode ? oParentNode["@$ui5.node.level"] + 1 : 1
+				});
+			};
 			const iOldIndex = this.aElements.indexOf(oChildNode);
-			// update the cache with the PATCH response (Note: "@odata.etag" is optional!)
-			_Helper.updateExisting(this.mChangeListeners, sChildPredicate, oChildNode, {
-				"@odata.etag" : oPatchResult["@odata.etag"],
-				"@$ui5.node.level" : oParentNode["@$ui5.node.level"] + 1
-			});
+			let iResult = 1;
+
+			if (this.oAggregation.expandTo > 1) {
+				const iOffset = _Helper.getPrivateAnnotation(oChildNode, "descendants", 0) + 1;
+				this.adjustDescendantCount(oChildNode, iOldIndex, -iOffset);
+				this.shiftRank(iOldIndex, -iOffset);
+				this.aElements.splice(iOldIndex, 1);
+				this.oFirstLevel.move(_Helper.getPrivateAnnotation(oChildNode, "rank"),
+					iPreorderRank, iOffset);
+				updateChildNode();
+				_Helper.setPrivateAnnotation(oChildNode, "rank", iPreorderRank);
+				switch (oParentNode ? oParentNode["@$ui5.node.isExpanded"] : true) {
+					case false:
+						iResult = this.expand(_GroupLock.$cached, sParentPredicate).unwrap() + 1;
+						// fall through
+					case true:
+						break;
+
+					default:
+						_Helper.updateAll(this.mChangeListeners, sParentPredicate, oParentNode,
+							{"@$ui5.node.isExpanded" : true}); // not a leaf anymore
+				}
+				const iNewIndex = this.aElements.indexOf(oParentNode) + 1; // 0 w/o oParentNode :-)
+				this.aElements.splice(iNewIndex, 0, oChildNode);
+				this.shiftRank(iNewIndex, +iOffset);
+				this.adjustDescendantCount(oChildNode, iNewIndex, +iOffset);
+
+				return iResult;
+			}
 
 			// remove original element from its cache's collection
 			const oOldParentCache = _Helper.getPrivateAnnotation(oChildNode, "parent");
-			oOldParentCache.removeElement(_Helper.getPrivateAnnotation(oChildNode, "index", 0),
+			oOldParentCache.removeElement(_Helper.getPrivateAnnotation(oChildNode, "rank", 0),
 				sChildPredicate);
 			if (oOldParentCache.getValue("$count") === 0) { // last child has gone
 				const oOldParent = this.aElements[iOldIndex - 1];
@@ -1056,18 +1153,19 @@ sap.ui.define([
 			}
 
 			// once oChildNode has moved, it should look 'created' because of its new position
-			_Helper.deletePrivateAnnotation(oChildNode, "index");
 			if (!_Helper.hasPrivateAnnotation(oChildNode, "transientPredicate")) {
 				_Helper.setPrivateAnnotation(oChildNode, "transientPredicate",
 					sTransientPredicate);
 				this.aElements.$byPredicate[sTransientPredicate] = oChildNode;
 				_Helper.updateAll(this.mChangeListeners, sChildPredicate, oChildNode,
 					{"@$ui5.context.isTransient" : false});
-				this.shiftIndex(iOldIndex, -1); // only shift indices after non-created ones
+				this.shiftRank(iOldIndex, -1); // only shift indices after non-created ones
 			}
+			_Helper.deletePrivateAnnotation(oChildNode, "rank");
 			this.aElements.splice(iOldIndex, 1);
 
-			let iResult = 1;
+			updateChildNode();
+
 			if (oReadPromise) {
 				_Helper.setPrivateAnnotation(oChildNode, "parent", oCache);
 				_Helper.setPrivateAnnotation(oParentNode, "cache", oCache);
@@ -1075,7 +1173,7 @@ sap.ui.define([
 				// Note: oChildNode already belongs to oCache!
 				this.aElements.$count -= 1; // #expand adjusts $count incl. oChildNode!
 				iResult = this.expand(_GroupLock.$cached, sParentPredicate).unwrap();
-				// Note: "index" created OK by #expand for oChildNode's siblings
+				// Note: "rank" created OK by #expand for oChildNode's siblings
 			} else {
 				if (!oCache) {
 					oCache = this.createGroupLevelCache(oParentNode);
@@ -1085,10 +1183,11 @@ sap.ui.define([
 						{"@$ui5.node.isExpanded" : true}); // not a leaf anymore
 				}
 				_Helper.setPrivateAnnotation(oChildNode, "parent", oCache);
-				oCache.restoreElement(undefined, 0, oChildNode, "");
+				oCache.restoreElement(0, oChildNode);
 
-				const iNewIndex = this.aElements.indexOf(oParentNode) + 1;
-				const aSpliced = _Helper.getPrivateAnnotation(oParentNode, "spliced");
+				const iNewIndex = this.aElements.indexOf(oParentNode) + 1; // 0 w/o oParentNode :-)
+				const aSpliced
+					= oParentNode && _Helper.getPrivateAnnotation(oParentNode, "spliced");
 				if (aSpliced) {
 					// Note: "@$ui5.node.level" will be adjusted by #expand for aSpliced!
 					oChildNode["@$ui5.node.level"] = aSpliced[0]["@$ui5.node.level"];
@@ -1145,7 +1244,7 @@ sap.ui.define([
 			bHasGrandTotalAtTop = this.oGrandTotalPromise
 				&& this.oAggregation.grandTotalAtBottomOnly !== true,
 			aReadPromises = [],
-			i, n,
+			i,
 			that = this;
 
 		/*
@@ -1186,7 +1285,12 @@ sap.ui.define([
 				this.readFirst(iFirstLevelIndex, iFirstLevelLength, iPrefetchLength,
 					oGroupLock, fnDataRequested));
 		} else {
-			for (i = iIndex, n = Math.min(iIndex + iLength, this.aElements.length); i < n; i += 1) {
+			const oReadRange = ODataUtils._getReadRange(this.aElements, iIndex, iLength,
+				iPrefetchLength,
+				// _getReadRange happily reads beyond aElements, so oElement may be undefined
+				(oElement) => !oElement || _Helper.hasPrivateAnnotation(oElement, "placeholder"));
+			const n = Math.min(oReadRange.start + oReadRange.length, this.aElements.length);
+			for (i = oReadRange.start; i < n; i += 1) {
 				oElement = this.aElements[i];
 				oCurrentParent = _Helper.hasPrivateAnnotation(oElement, "placeholder")
 					? _Helper.getPrivateAnnotation(oElement, "parent")
@@ -1201,10 +1305,10 @@ sap.ui.define([
 						oGapParent = oCurrentParent;
 					}
 				} else if (iGapStart !== undefined
-						&& _Helper.getPrivateAnnotation(oElement, "index")
-							!== _Helper.getPrivateAnnotation(this.aElements[i - 1], "index") + 1) {
-					// Note: w/ side effect, indices might not be consecutive => split gap
-					// Note: an undefined "index" causes a split gap, which is important!
+						&& _Helper.getPrivateAnnotation(oElement, "rank")
+							!== _Helper.getPrivateAnnotation(this.aElements[i - 1], "rank") + 1) {
+					// Note: w/ side effect, ranks might not be consecutive => split gap
+					// Note: an undefined "rank" causes a split gap, which is important!
 					readGap(iGapStart, i);
 					iGapStart = i;
 				}
@@ -1372,8 +1476,8 @@ sap.ui.define([
 	_AggregationCache.prototype.readGap = function (oCache, iStart, iEnd, oGroupLock,
 			fnDataRequested) {
 		const oStartElement = this.aElements[iStart];
-		const iIndex = _Helper.getPrivateAnnotation(oStartElement, "index");
-		if (iIndex === undefined) {
+		const iRank = _Helper.getPrivateAnnotation(oStartElement, "rank");
+		if (iRank === undefined) {
 			if (iEnd - iStart !== 1) {
 				throw new Error("Not just a single created persisted");
 			}
@@ -1395,7 +1499,7 @@ sap.ui.define([
 			oCache.setQueryOptions(mQueryOptions, true);
 		}
 
-		const oPromise = oCache.read(iIndex, iEnd - iStart, 0, oGroupLock, fnDataRequested, true)
+		const oPromise = oCache.read(iRank, iEnd - iStart, 0, oGroupLock, fnDataRequested, true)
 			.then((oResult) => {
 				// Note: this code must be idempotent, it might well run twice!
 				var bGapHasMoved = false,
@@ -1417,7 +1521,7 @@ sap.ui.define([
 					}
 				}
 
-				this.addElements(oResult.value, iStart, oCache, iIndex);
+				this.addElements(oResult.value, iStart, oCache, iRank);
 
 				if (bGapHasMoved) {
 					oError = new Error("Collapse or expand before read has finished");
@@ -1447,6 +1551,37 @@ sap.ui.define([
 		return this.oFirstLevel.refreshKeptElements.call(this, oGroupLock, fnOnRemove, true);
 	};
 
+	/**
+	 * Requests the (limited preorder) rank of the given element which must belong to
+	 * <code>this.oFirstLevel</code>.
+	 *
+	 * @param {object} oElement - The element
+	 * @param {sap.ui.model.odata.v4.lib._GroupLock} oGroupLock
+	 *   A lock for the group ID to be used for the GET request
+	 * @returns {Promise<number>}
+	 *   A promise which is resolved with the (limited preorder) rank of the given element, or
+	 *   rejected in case of an error
+	 *
+	 * @private
+	 */
+	_AggregationCache.prototype.requestRank = async function (oElement, oGroupLock) {
+		const sMetaPath = this.oAggregation.$metaPath;
+		const {$apply, $orderby} = this.oFirstLevel.getQueryOptions();
+		const mQueryOptions = {
+			$apply,
+			$filter : _Helper.getKeyFilter(oElement, sMetaPath, this.getTypes()),
+			$select : this.oAggregation.$LimitedRank
+		};
+		if ($orderby) {
+			mQueryOptions.$orderby = $orderby;
+		}
+		const sResourcePath = this.sResourcePath
+			+ this.oRequestor.buildQueryString(sMetaPath, mQueryOptions, false, true);
+		const oResult = await this.oRequestor.request("GET", sResourcePath, oGroupLock);
+
+		return parseInt(_Helper.drillDown(oResult.value[0], this.oAggregation.$LimitedRank));
+	};
+
 	/**
 	 * @override
 	 * @see sap.ui.model.odata.v4.lib._CollectionCache#reset
@@ -1512,27 +1647,33 @@ sap.ui.define([
 	};
 
 	/**
-	 * Shifts the $skip "index" of all siblings (nodes or placeholders) after the node at the given
-	 * index by the given offset, except for created elements (where it is always
-	 * <code>undefined</code>).
+	 * Shifts the rank (aka. $skip index) of all siblings (nodes or placeholders) after the node at
+	 * the given array index by the given offset, except for elements where it is
+	 * <code>undefined</code> or lower than the node's own rank. If the node at the given index
+	 * itself has an <code>undefined</code> rank, nothing is shifted. Note that inside
+	 * <code>this.oFirstLevel</code> not only siblings are affected.
 	 *
 	 * @param {number} iIndex
 	 *   Index in <code>this.aElements</code> of a node
 	 * @param {number} iOffset
-	 *   Offset to add to "index"
+	 *   Offset to add to rank
 	 *
 	 * @private
 	 */
-	_AggregationCache.prototype.shiftIndex = function (iIndex, iOffset) {
-		const aElements = this.aElements;
-		const oNode = aElements[iIndex];
+	_AggregationCache.prototype.shiftRank = function (iIndex, iOffset) {
+		const oNode = this.aElements[iIndex];
+		const iMinRank = _Helper.getPrivateAnnotation(oNode, "rank");
+		if (iMinRank === undefined) {
+			return;
+		}
+
 		const oCache = _Helper.getPrivateAnnotation(oNode, "parent");
-		for (let i = iIndex + 1; i < aElements.length; i += 1) {
-			const oSibling = aElements[i];
+		for (let i = iIndex + 1; i < this.aElements.length; i += 1) {
+			const oSibling = this.aElements[i];
 			if (_Helper.getPrivateAnnotation(oSibling, "parent") === oCache) {
-				const iIndex = _Helper.getPrivateAnnotation(oSibling, "index");
-				if (iIndex !== undefined) {
-					_Helper.setPrivateAnnotation(oSibling, "index", iIndex + iOffset);
+				const iRank = _Helper.getPrivateAnnotation(oSibling, "rank");
+				if (iRank >= iMinRank) { // Note: undefined >= ... is false
+					_Helper.setPrivateAnnotation(oSibling, "rank", iRank + iOffset);
 				}
 			}
 			if (oCache !== this.oFirstLevel
@@ -1576,9 +1717,9 @@ sap.ui.define([
 		_AggregationHelper.markSplicedStale(oElement);
 		delete this.aElements.$byPredicate[sPredicate];
 		// drop original element from its cache's collection
-		const iIndex = _Helper.getPrivateAnnotation(oElement, "index");
-		if (iIndex !== undefined) {
-			_Helper.getPrivateAnnotation(oElement, "parent").drop(iIndex, sPredicate, true);
+		const iRank = _Helper.getPrivateAnnotation(oElement, "rank");
+		if (iRank !== undefined) {
+			_Helper.getPrivateAnnotation(oElement, "parent").drop(iRank, sPredicate, true);
 		} // else: special handling inside #readGap
 	};
 
@@ -1688,7 +1829,7 @@ sap.ui.define([
 			return sPredicate;
 		}
 
-		switch (_Helper.drillDown(oElement, oAggregation.$DrillStateProperty)) {
+		switch (_Helper.drillDown(oElement, oAggregation.$DrillState)) {
 			case "expanded":
 				bIsExpanded = true;
 				break;
@@ -1700,24 +1841,24 @@ sap.ui.define([
 			default: // "leaf"
 				// bIsExpanded = undefined;
 		}
-		_Helper.deleteProperty(oElement, oAggregation.$DrillStateProperty);
+		_Helper.deleteProperty(oElement, oAggregation.$DrillState);
 		if (oGroupNode) {
 			iLevel = oGroupNode["@$ui5.node.level"] + 1;
 		} else {
-			sDistanceFromRoot = _Helper.drillDown(oElement, oAggregation.$DistanceFromRootProperty);
+			sDistanceFromRoot = _Helper.drillDown(oElement, oAggregation.$DistanceFromRoot);
 			if (sDistanceFromRoot) { // Edm.Int64
-				_Helper.deleteProperty(oElement, oAggregation.$DistanceFromRootProperty);
+				_Helper.deleteProperty(oElement, oAggregation.$DistanceFromRoot);
 				iLevel = parseInt(sDistanceFromRoot) + 1;
 			}
 		}
 		// set the node values
 		_AggregationHelper.setAnnotations(oElement, bIsExpanded, /*bIsTotal*/undefined, iLevel);
 
-		if (oAggregation.$LimitedDescendantCountProperty) {
+		if (oAggregation.$LimitedDescendantCount) {
 			sLimitedDescendantCount
-				= _Helper.drillDown(oElement, oAggregation.$LimitedDescendantCountProperty);
+				= _Helper.drillDown(oElement, oAggregation.$LimitedDescendantCount);
 			if (sLimitedDescendantCount) {
-				_Helper.deleteProperty(oElement, oAggregation.$LimitedDescendantCountProperty);
+				_Helper.deleteProperty(oElement, oAggregation.$LimitedDescendantCount);
 				if (sLimitedDescendantCount !== "0") { // Edm.Int64
 					_Helper.setPrivateAnnotation(oElement, "descendants",
 						parseInt(sLimitedDescendantCount));