@openui5/sap.ui.core 1.99.0 → 1.100.1

package/src/sap/ui/model/odata/v4/ODataBinding.js

@@ -165,8 +165,20 @@ sap.ui.define([
 						throw new Error("Unsupported operation mode: " + vValue);
 					}
 					break;
-				case "$$canonicalPath":
 				case "$$getKeepAliveContext":
+					if (that.isRelative() && !mParameters.$$ownRequest) {
+						throw new Error(
+							"$$getKeepAliveContext requires $$ownRequest in a relative binding");
+					}
+					["$$aggregation", "$$canonicalPath", "$$sharedRequest"]
+						.forEach(function (sForbidden) {
+							if (sForbidden in mParameters) {
+								throw new Error("Cannot combine $$getKeepAliveContext and "
+									+ sForbidden);
+							}
+						});
+					// falls through
+				case "$$canonicalPath":
 				case "$$noPatch":
 				case "$$ownRequest":
 				case "$$patchWithoutSideEffects":
@@ -254,8 +266,8 @@ sap.ui.define([
 	 *   The resource path
 	 * @param {sap.ui.model.Context} [oContext]
 	 *   The context instance to be used, undefined for absolute bindings
-	 * @param {boolean} [bOldCacheReadOnly]
-	 *   Whether the old cache is read-only and must be kept intact - not reset and reused!
+	 * @param {boolean} [bKeepCreated]
+	 *   Whether created persisted elements shall be kept in place
 	 * @param {sap.ui.model.odata.v4.lib._Cache} [oOldCache]
 	 *   The old cache, in case it may be reused
 	 * @returns {sap.ui.model.odata.v4.lib._Cache}
@@ -265,7 +277,7 @@ sap.ui.define([
 	 * @private
 	 */
 	ODataBinding.prototype.createAndSetCache = function (mQueryOptions, sResourcePath, oContext,
-			bOldCacheReadOnly, oOldCache) {
+			bKeepCreated, oOldCache) {
 		var oCache, sDeepResourcePath, iGeneration;
 
 		this.mCacheQueryOptions = Object.assign({}, this.oModel.mUriParameters, mQueryOptions);
@@ -289,7 +301,7 @@ sap.ui.define([
 			} else {
 				sDeepResourcePath = this.oModel.resolve(this.sPath, oContext).slice(1);
 				oCache = this.doCreateCache(sResourcePath, this.mCacheQueryOptions, oContext,
-					sDeepResourcePath, bOldCacheReadOnly, oOldCache);
+					sDeepResourcePath, bKeepCreated, oOldCache);
 				if (!(this.mParameters && this.mParameters.$$sharedRequest)) {
 					this.mCacheByResourcePath = this.mCacheByResourcePath || {};
 					this.mCacheByResourcePath[sResourcePath] = oCache;
@@ -299,15 +311,13 @@ sap.ui.define([
 			}
 		} else { // absolute binding
 			oCache = this.doCreateCache(sResourcePath, this.mCacheQueryOptions, undefined,
-				undefined, bOldCacheReadOnly, oOldCache);
+				undefined, bKeepCreated, oOldCache);
 		}
-		if (oOldCache !== oCache) {
-			if (oOldCache) {
-				oOldCache.setActive(false);
-			}
-			if (this.mLateQueryOptions) {
-				oCache.setLateQueryOptions(this.mLateQueryOptions);
-			}
+		if (oOldCache && oOldCache !== oCache) {
+			oOldCache.setActive(false);
+		}
+		if (this.mLateQueryOptions) {
+			oCache.setLateQueryOptions(this.mLateQueryOptions);
 		}
 		this.oCache = oCache;
 
@@ -348,8 +358,8 @@ sap.ui.define([
 	 *   The context instance to be used, must be <code>undefined</code> for absolute bindings
 	 * @param {string} [sDeepResourcePath=sResourcePath]
 	 *   The deep resource path to be used to build the target path for bound messages
-	 * @param {boolean} [bOldCacheReadOnly]
-	 *   Whether the old cache is read-only and must be kept intact - not reset and reused!
+	 * @param {boolean} [bKeepCreated]
+	 *   Whether created persisted elements shall be kept in place
 	 * @param {sap.ui.model.odata.v4.lib._Cache} [oOldCache]
 	 *   The old cache, in case it may be reused
 	 * @returns {sap.ui.model.odata.v4.lib._Cache}
@@ -402,9 +412,8 @@ sap.ui.define([
 	 * @param {boolean} [bKeepQueryOptions]
 	 *   Whether to keep existing (late) query options and not to run auto-$expand/$select again
 	 *   (cannot be combined with <code>bIgnoreParentCache</code>!)
-	 * @param {boolean} [bKeepCacheOnError]
-	 *   If <code>true</code>, the binding data remains unchanged if the refresh fails. This implies
-	 *   that the old cache must be kept intact - not reset and reused!
+	 * @param {boolean} [bKeepCreated]
+	 *   Whether created persisted elements shall be kept in place
 	 * @throws {Error}
 	 *   If auto-$expand/$select is still running and query options shall be kept (this case is just
 	 *   not yet implemented and should not be needed)
@@ -412,7 +421,7 @@ sap.ui.define([
 	 * @private
 	 */
 	ODataBinding.prototype.fetchCache = function (oContext, bIgnoreParentCache, bKeepQueryOptions,
-		bKeepCacheOnError) {
+		bKeepCreated) {
 		var oCache = this.oCache,
 			oCallToken = {
 				// propagate old cache from first call of fetchCache to the latest call
@@ -435,10 +444,10 @@ sap.ui.define([
 		this.oCache = undefined;
 		this.oFetchCacheCallToken = oCallToken;
 		if (bKeepQueryOptions) {
-			// asynchronously re-create an equivalent cache
+			// asynchronously re-create an equivalent cache, but skip auto-$expand/$select
 			this.oCachePromise = SyncPromise.resolve(Promise.resolve()).then(function () {
 				return that.createAndSetCache(that.mCacheQueryOptions, oCache.getResourcePath(),
-					oContext, bKeepCacheOnError, oCache);
+					oContext, bKeepCreated, oCache);
 			});
 			return;
 		}
@@ -465,7 +474,7 @@ sap.ui.define([
 						throw oError;
 					}
 					return that.createAndSetCache(mQueryOptions, sResourcePath, oContext,
-						bKeepCacheOnError, oCallToken.oOldCache);
+						bKeepCreated, oCallToken.oOldCache);
 				});
 			}
 			that.oCache = null;
@@ -828,11 +837,12 @@ sap.ui.define([
 	 *   Whether to ignore changes which will not be lost by APIs like
 	 *   {@link sap.ui.model.odata.v4.ODataListBinding#changeParameters changeParameters},
 	 *   {@link sap.ui.model.odata.v4.ODataListBinding#filter filter},
+	 *   {@link sap.ui.model.odata.v4.ODataListBinding#refresh refresh} (since 1.100.0),
 	 *   {@link sap.ui.model.odata.v4.ODataListBinding#sort sort}, or
 	 *   {@link sap.ui.model.odata.v4.ODataListBinding#suspend suspend} because they relate to a
-	 *   {@link sap.ui.model.odata.v4.Context#setKeepAlive kept-alive} context of this binding.
-	 *   Since 1.98.0, {@link sap.ui.model.odata.v4.Context#isTransient transient} contexts
-	 *   of a {@link #getRootBinding root binding} are treated as kept-alive by this flag.
+	 *   {@link sap.ui.model.odata.v4.Context#setKeepAlive kept-alive} context of this binding
+	 *   (since 1.97.0). Since 1.98.0, {@link sap.ui.model.odata.v4.Context#isTransient transient}
+	 *   contexts of a {@link #getRootBinding root binding} are treated as kept-alive by this flag.
 	 *   Since 1.99.0, the same happens for bindings using the <code>$$ownRequest</code> parameter
 	 *   (see {@link sap.ui.model.odata.v4.ODataModel#bindList}).
 	 * @returns {boolean}
@@ -990,8 +1000,8 @@ sap.ui.define([
 	 * the last call determines the binding's data; it is <b>independent</b> of the order of calls
 	 * to {@link sap.ui.model.odata.v4.ODataModel#submitBatch} with the given group ID.
 	 *
-	 * If there are pending changes, an error is thrown. Use {@link #hasPendingChanges} to check if
-	 * there are pending changes. If there are changes, call
+	 * If there are pending changes that cannot be ignored, an error is thrown. Use
+	 * {@link #hasPendingChanges} to check if there are such pending changes. If there are, call
 	 * {@link sap.ui.model.odata.v4.ODataModel#submitBatch} to submit the changes or
 	 * {@link sap.ui.model.odata.v4.ODataModel#resetChanges} to reset the changes before calling
 	 * {@link #refresh}.
@@ -1006,10 +1016,18 @@ sap.ui.define([
 	 *
 	 *   Valid values are <code>undefined</code>, '$auto', '$auto.*', '$direct' or application group
 	 *   IDs as specified in {@link sap.ui.model.odata.v4.ODataModel}.
-	 * @throws {Error}
-	 *   If the given group ID is invalid, the binding has pending changes, refresh on this
-	 *   binding is not supported, a group ID different from the binding's group ID is specified
-	 *   for a suspended binding, or a value of type boolean is given.
+	 * @throws {Error} If
+	 *   <ul>
+	 *     <li> the given group ID is invalid,
+	 *     <li> there are pending changes that cannot be ignored,
+	 *     <li> refresh on this binding is not supported,
+	 *     <li> a group ID different from the binding's group ID is specified for a suspended
+	 *       binding,
+	 *     <li> or a value of type boolean is given.
+	 *   </ul> Since 1.100.0, pending changes are ignored if they relate to a
+	 *   {@link sap.ui.model.odata.v4.Context#setKeepAlive kept-alive} context of this binding, and
+	 *   {@link sap.ui.model.odata.v4.Context#isTransient transient} contexts of a
+	 *   {@link #getRootBinding root binding} do not count as pending changes.
 	 *
 	 * @public
 	 * @see sap.ui.model.Binding#refresh
@@ -1159,7 +1177,7 @@ sap.ui.define([
 		if (!this.isRoot()) {
 			throw new Error("Refresh on this binding is not supported");
 		}
-		if (this.hasPendingChanges()) {
+		if (this.hasPendingChanges(true)) {
 			throw new Error("Cannot refresh due to pending changes");
 		}
 		this.oModel.checkGroupId(sGroupId);

package/src/sap/ui/model/odata/v4/ODataContextBinding.js

@@ -74,7 +74,7 @@ sap.ui.define([
 		 * @mixes sap.ui.model.odata.v4.ODataParentBinding
 		 * @public
 		 * @since 1.37.0
-		 * @version 1.99.0
+		 * @version 1.100.1
 		 *
 		 * @borrows sap.ui.model.odata.v4.ODataBinding#getGroupId as #getGroupId
 		 * @borrows sap.ui.model.odata.v4.ODataBinding#getRootBinding as #getRootBinding
@@ -840,9 +840,7 @@ sap.ui.define([
 	 * Since 1.98.0, a single-valued navigation property can be treated like a function if
 	 * <ul>
 	 *   <li> it has the same type as the operation binding's parent context,
-	 *   <li> that parent context is in the collection (has an index, see
-	 *     {@link sap.ui.model.odata.v4.Context#getIndex}) of a list binding for a top-level entity
-	 *     set,
+	 *   <li> that parent context is in a list binding for a top-level entity set,
 	 *   <li> there is a navigation property binding which points to that same entity set,
 	 *   <li> no operation parameters have been set,
 	 *   <li> the <code>bReplaceWithRVC</code> parameter is used.
@@ -950,7 +948,7 @@ sap.ui.define([
 					+ sResolvedPath);
 			}
 			if (bReplaceWithRVC) {
-				if (!this.oContext.getBinding || this.oContext.iIndex === undefined) {
+				if (!this.oContext.getBinding) {
 					throw new Error("Cannot replace this parent context: " + this.oContext);
 				}
 				this.oContext.getBinding().checkKeepAlive(this.oContext);
@@ -1268,6 +1266,36 @@ sap.ui.define([
 			&& !oMetadata.$EntitySetPath.includes("/"); // case 3
 	};
 
+	/**
+	 * Refreshes all dependent bindings with the given parameters and waits for them to have
+	 * finished.
+	 *
+	 * @param {string} sResourcePathPrefix
+	 *   The resource path prefix which is used to delete the dependent caches and corresponding
+	 *   messages; may be "" but not <code>undefined</code>
+	 * @param {string} [sGroupId]
+	 *   The group ID to be used for refresh
+	 * @param {boolean} [bCheckUpdate]
+	 *   If <code>true</code>, a property binding is expected to check for updates
+	 * @param {boolean} [bKeepCacheOnError]
+	 *   If <code>true</code>, the binding data remains unchanged if the refresh fails
+	 * @returns {sap.ui.base.SyncPromise}
+	 *   A promise resolving when all dependent bindings are refreshed; it is rejected
+	 *   when the refresh fails; the promise is resolved immediately on a suspended binding
+	 * @throws {Error}
+	 *   If the binding's root binding is suspended and a group ID different from the binding's
+	 *   group ID is given
+	 *
+	 * @private
+	 */
+	ODataContextBinding.prototype.refreshDependentBindings = function (sResourcePathPrefix,
+			sGroupId, bCheckUpdate, bKeepCacheOnError) {
+		return SyncPromise.all(this.getDependentBindings().map(function (oDependentBinding) {
+			return oDependentBinding.refreshInternal(sResourcePathPrefix, sGroupId, bCheckUpdate,
+				bKeepCacheOnError);
+		}));
+	};
+
 	/**
 	 * @override
 	 * @see sap.ui.model.odata.v4.ODataBinding#refreshInternal

package/src/sap/ui/model/odata/v4/ODataListBinding.js

@@ -58,7 +58,7 @@ sap.ui.define([
 		 * @mixes sap.ui.model.odata.v4.ODataParentBinding
 		 * @public
 		 * @since 1.37.0
-		 * @version 1.99.0
+		 * @version 1.100.1
 		 * @borrows sap.ui.model.odata.v4.ODataBinding#getGroupId as #getGroupId
 		 * @borrows sap.ui.model.odata.v4.ODataBinding#getRootBinding as #getRootBinding
 		 * @borrows sap.ui.model.odata.v4.ODataBinding#getUpdateGroupId as #getUpdateGroupId
@@ -423,6 +423,9 @@ sap.ui.define([
 			oOldAggregation = this.mParameters && this.mParameters.$$aggregation,
 			sOldApply = this.mQueryOptions && this.mQueryOptions.$apply;
 
+		if ("$$getKeepAliveContext" in mParameters && "$apply" in mParameters) {
+			throw new Error("Cannot combine $$getKeepAliveContext and $apply");
+		}
 		if ("$$aggregation" in mParameters) {
 			if ("$apply" in mParameters) {
 				throw new Error("Cannot combine $$aggregation and $apply");
@@ -979,20 +982,13 @@ sap.ui.define([
 			if (this.aContexts[iStart + i] === undefined && aResults[i]) {
 				bChanged = true;
 				i$skipIndex = iStart + i - this.iCreatedContexts; // index on server ($skip)
-				sPredicate = _Helper.getPrivateAnnotation(aResults[i], "predicate")
-					|| _Helper.getPrivateAnnotation(aResults[i], "transientPredicate");
+				sPredicate = _Helper.getPrivateAnnotation(aResults[i], "predicate");
 				sContextPath = sPath + (sPredicate || "/" + i$skipIndex);
 				oContext = this.mPreviousContextsByPath[sContextPath];
-				if (oContext && (!oContext.created() || oContext.isTransient())) {
-					// reuse the previous context, unless it is created and persisted
+				if (oContext && !oContext.created()) {
+					// reuse the previous context, unless it is created (and persisted)
 					delete this.mPreviousContextsByPath[sContextPath];
-					if (oContext.isTransient() && !this.iCreatedContexts) {
-						// this can only happen in bindings w/o cache, where all created contexts
-						// are active
-						this.iCreatedContexts = this.iActiveContexts = -oContext.iIndex;
-					} else {
-						oContext.iIndex = i$skipIndex;
-					}
+					oContext.iIndex = i$skipIndex;
 					oContext.checkUpdate();
 				} else {
 					oContext = Context.create(oModel, this, sContextPath, i$skipIndex);
@@ -1148,7 +1144,7 @@ sap.ui.define([
 	 * @see sap.ui.model.odata.v4.ODataBinding#doCreateCache
 	 */
 	ODataListBinding.prototype.doCreateCache = function (sResourcePath, mQueryOptions, oContext,
-			sDeepResourcePath, bOldCacheReadOnly, oOldCache) {
+			sDeepResourcePath, bKeepCreated, oOldCache) {
 		var sBindingPath,
 			aKeptElementPaths,
 			oCache,
@@ -1161,10 +1157,10 @@ sap.ui.define([
 				return that.mPreviousContextsByPath[sPath].isKeepAlive();
 			});
 
-			if (!bOldCacheReadOnly && (aKeptElementPaths.length || this.iCreatedContexts)) {
+			if (this.iCreatedContexts || !bKeepCreated && aKeptElementPaths.length) {
 				oOldCache.reset(aKeptElementPaths.map(function (sPath) {
 					return _Helper.getRelativePath(sPath, sBindingPath);
-				}));
+				}), bKeepCreated);
 				// Note: #inheritQueryOptions as called below should not matter in case of own
 				// requests, which are a precondition for kept-alive elements
 				oOldCache.setQueryOptions(mQueryOptions, true);
@@ -1173,9 +1169,11 @@ sap.ui.define([
 			}
 		}
 
-		oCache = _AggregationCache.create(this.oModel.oRequestor, sResourcePath, sDeepResourcePath,
-			this.mParameters.$$aggregation, this.inheritQueryOptions(mQueryOptions, oContext),
-			this.oModel.bAutoExpandSelect, this.bSharedRequest);
+		mQueryOptions = this.inheritQueryOptions(mQueryOptions, oContext);
+		oCache = this.getCacheAndMoveKeepAliveContexts(sResourcePath, mQueryOptions)
+			|| _AggregationCache.create(this.oModel.oRequestor, sResourcePath, sDeepResourcePath,
+				this.mParameters.$$aggregation, mQueryOptions, this.oModel.bAutoExpandSelect,
+				this.bSharedRequest);
 
 		if (aKeptElementPaths && aKeptElementPaths.length) {
 			oCache.setLateQueryOptions(oOldCache.getLateQueryOptions());
@@ -1243,8 +1241,13 @@ sap.ui.define([
 			bNew = true;
 		}
 		oOldContext.iIndex = undefined;
-		this.aContexts[iIndex] = oResult;
-		this.oCache.doReplaceWith(iIndex, oElement);
+		if (iIndex === undefined) {
+			this.mPreviousContextsByPath[sPath] = oResult;
+			this.oCache.addKeptElement(oElement);
+		} else {
+			this.aContexts[iIndex] = oResult;
+			this.oCache.doReplaceWith(iIndex, oElement);
+		}
 		if (bKeepAlive) {
 			this.mPreviousContextsByPath[oOldContext.getPath()] = oOldContext;
 			if (bNew) {
@@ -1826,6 +1829,62 @@ sap.ui.define([
 		}).concat(Object.values(this.mPreviousContextsByPath));
 	};
 
+	/**
+	 * Tries to get a cache from the model. This is only relevant for the $$getKeepAlive scenario
+	 * when the model created a temporary binding for this binding's path. If there is such a
+	 * binding, its contexts are moved here, it is destroyed and its cache is returned.
+	 *
+	 * @param {string} sResourcePath
+	 *   The resoure path for the cache
+	 * @param {object} mQueryOptions
+	 *   The query options for the cache
+	 * @returns {sap.ui.model.odata.v4.lib._CollectionCache|undefined}
+	 *   The cache or <code>undefined</code> if the model has no matching temporary binding
+	 *
+	 * @private
+	 */
+	ODataListBinding.prototype.getCacheAndMoveKeepAliveContexts = function (sResourcePath,
+			mQueryOptions) {
+		var oBinding,
+			oCache,
+			that = this;
+
+		if (!this.mParameters.$$getKeepAliveContext) {
+			return undefined;
+		}
+		// $$canonicalPath is not allowed, binding path and resource path are (almost) identical
+		oBinding = this.oModel.releaseKeepAliveBinding("/" + sResourcePath);
+		if (!oBinding) {
+			return undefined;
+		}
+
+		Object.keys(oBinding.mParameters).concat(Object.keys(this.mParameters))
+			.forEach(function (sParameter) {
+				if ((sParameter[0] !== "$" || sParameter === "$$patchWithoutSideEffects"
+						|| sParameter === "$$updateGroupId")
+						&& that.mParameters[sParameter] !== oBinding.mParameters[sParameter]) {
+					throw new Error(that + ": parameter does not match getKeepAliveContext: "
+						+ sParameter);
+				}
+			});
+		// createAndSetCache copies them to the cache later
+		this.mLateQueryOptions = _Helper.clone(mQueryOptions);
+		_Helper.aggregateExpandSelect(this.mLateQueryOptions, oBinding.mLateQueryOptions);
+		this.mPreviousContextsByPath = oBinding.mPreviousContextsByPath;
+		Object.values(this.mPreviousContextsByPath).forEach(function (oContext) {
+			oContext.oBinding = that;
+		});
+		oCache = oBinding.oCache;
+		oCache.setQueryOptions(mQueryOptions);
+		// avoid that the cache is set inactive or that contexts are destroyed
+		oBinding.oCache = null;
+		oBinding.oCachePromise = SyncPromise.resolve(null);
+		oBinding.mPreviousContextsByPath = {};
+		oBinding.destroy();
+
+		return oCache;
+	};
+
 	/**
 	 * Returns already created binding contexts for all entities in this list binding for the range
 	 * determined by the given start index <code>iStart</code> and <code>iLength</code>.
@@ -2315,30 +2374,73 @@ sap.ui.define([
 
 	/**
 	 * Calls {@link sap.ui.model.odata.v4.Context#setKeepAlive} at the context for the given path
-	 * and returns it.
+	 * and returns it. Since 1.100.0 the function always returns such a context. If none exists yet,
+	 * it is created without data and a request for its entity is sent.
 	 *
 	 * @param {string} sPath
 	 *   The path of the context to be kept alive
 	 * @param {boolean} [bRequestMessages]
 	 *   Whether to request messages for the context's entity
+	 * @param {string} [sGroupId]
+	 *   The group ID used for read requests for the context's entity or its properties. If not
+	 *   given, the binding's {@link #getGroupId group ID} is used. Supported since 1.100.0
 	 * @returns {sap.ui.model.odata.v4.Context|undefined}
-	 *   The kept-alive context, or <code>undefined</code> if it does not exist
-	 * @throws {Error}
-	 *   If {@link sap.ui.model.odata.v4.Context#setKeepAlive} fails
+	 *   The kept-alive context, or <code>undefined</code> if the binding's root binding is
+	 *   suspended and no context with the given path exists
+	 * @throws {Error} If
+	 *   <ul>
+	 *     <li> the group ID is invalid,
+	 *     <li> the binding is unresolved,
+	 *     <li> the given context path does not match this binding,
+	 *     <li> or {@link sap.ui.model.odata.v4.Context#setKeepAlive} fails
+	 *   </ul>
 	 *
 	 * @public
 	 * @see sap.ui.model.odata.v4.Model#getKeepAliveContext
 	 * @since 1.99.0
 	 */
-	ODataListBinding.prototype.getKeepAliveContext = function (sPath, bRequestMessages) {
+	ODataListBinding.prototype.getKeepAliveContext = function (sPath, bRequestMessages, sGroupId) {
 		var oContext = this.mPreviousContextsByPath[sPath]
 				|| this.aContexts.find(function (oCandidate) {
 					return oCandidate && oCandidate.getPath() === sPath;
-				});
+				}),
+			iPredicateIndex = this.oModel.getPredicateIndex(sPath),
+			sResolvedPath = this.getResolvedPath();
 
-		if (oContext) {
-			oContext.setKeepAlive(true, oContext.fnOnBeforeDestroy, bRequestMessages);
+		this.oModel.checkGroupId(sGroupId);
+		if (!oContext) {
+			if (!sResolvedPath) {
+				throw new Error("Binding is unresolved: " + this);
+			}
+			if (this.isRootBindingSuspended()) {
+				return undefined;
+			}
+			if (sPath.slice(0, iPredicateIndex) !== sResolvedPath) {
+				throw new Error(this + ": Not a valid context path: " + sPath);
+			}
+			oContext = Context.create(this.oModel, this, sPath);
+			this.mPreviousContextsByPath[sPath] = oContext;
+			this.oCachePromise.then(function (oCache) {
+				// call ASAP so that dependent property bindings find the entity in the cache
+				var oElement = oCache.createEmptyElement(sPath.slice(iPredicateIndex));
+
+				if (sGroupId) {
+					_Helper.setPrivateAnnotation(oElement, "groupId", sGroupId);
+				}
+			});
+			// *request*Object so that requestProperty definitely runs after setKeepAlive and adds
+			// to mLateProperties
+			this.oModel.getMetaModel().requestObject(_Helper.getMetaPath(sResolvedPath) + "/")
+				.then(function (oType) {
+					// ensure that the key properties are requested even if unbound
+					return oContext.requestProperty(oType.$Key.map(function (vKey) {
+						return typeof vKey === "object" ? Object.values(vKey)[0] : vKey;
+					}));
+				})
+				.catch(this.oModel.getReporter());
 		}
+
+		oContext.setKeepAlive(true, oContext.fnOnBeforeDestroy, bRequestMessages);
 		return oContext;
 	};
 
@@ -2452,6 +2554,18 @@ sap.ui.define([
 	};
 
 	/**
+	 * Check whether this binding is an active $$getKeepAliveContext binding for the given path.
+	 *
+	 * @param {string} sPath - An absolute binding path
+	 * @returns {boolean} - Whether this binding matches
+	 *
+	 * @private
+	 */
+	ODataListBinding.prototype.isKeepAliveBindingFor = function (sPath) {
+		return this.mParameters.$$getKeepAliveContext && this.getResolvedPath() === sPath;
+	};
+
+		/**
 	 * Enhance the inherited query options by the given query options if this binding does not have
 	 * any binding parameters. If both have a '$orderby', the resulting '$orderby' is the
 	 * concatenation of both '$orderby' with the given one first. If both have a '$filter', the
@@ -2557,16 +2671,11 @@ sap.ui.define([
 			_bCheckUpdate, bKeepCacheOnError) {
 		var that = this;
 
-		function onRemove(sPredicate) {
-			var sPath = that.getResolvedPath();
-
-			that.mPreviousContextsByPath[sPath + sPredicate].resetKeepAlive();
-		}
-
 		// calls refreshInternal on all given bindings and returns an array of promises
 		function refreshAll(aBindings) {
 			return aBindings.map(function (oBinding) {
-				if (oBinding.bIsBeingDestroyed) {
+				if (oBinding.bIsBeingDestroyed
+						|| oBinding.getContext().isKeepAlive() && oBinding.hasPendingChanges()) {
 					return;
 				}
 				// Call refreshInternal with bCheckUpdate = false because property bindings
@@ -2588,6 +2697,7 @@ sap.ui.define([
 		return this.oCachePromise.then(function (oCache) {
 			var iActiveContexts = that.iActiveContexts,
 				iCreatedContexts = that.iCreatedContexts,
+				aContexts = that.aContexts.slice(0, iCreatedContexts),
 				aDependentBindings,
 				oKeptElementsPromise,
 				oPromise = that.oRefreshPromise;
@@ -2596,7 +2706,15 @@ sap.ui.define([
 				that.removeCachesAndMessages(sResourcePathPrefix);
 				that.fetchCache(that.oContext, false, /*bKeepQueryOptions*/true, bKeepCacheOnError);
 				oKeptElementsPromise = that.oCachePromise.then(function (oNewCache) {
-					return oNewCache.refreshKeptElements(that.lockGroup(sGroupId), onRemove);
+					return oNewCache.refreshKeptElements(that.lockGroup(sGroupId),
+						function onRemove(sPredicate, iIndex) {
+							if (iIndex === undefined) {
+								that.mPreviousContextsByPath[that.getResolvedPath() + sPredicate]
+									.resetKeepAlive();
+							} else { // Note: implies oContext.created()
+								that.destroyCreated(that.aContexts[iIndex]);
+							}
+						});
 				}).catch(function (oError) {
 					that.oModel.reportError("Failed to refresh kept-alive elements", sClassName,
 						oError);
@@ -2608,22 +2726,38 @@ sap.ui.define([
 							throw oError;
 						}
 						return that.fetchResourcePath(that.oContext).then(function (sResourcePath) {
+							var i;
+
 							if (!that.bRelative || oCache.getResourcePath() === sResourcePath) {
-								that.oCache = oCache;
-								that.oCachePromise = SyncPromise.resolve(oCache);
+								if (that.oCache === oCache) {
+									oCache.restore(true);
+								} else { // still needed in case of _AggregationCache
+									oCache.setActive(true);
+									that.oCache = oCache;
+									that.oCachePromise = SyncPromise.resolve(oCache);
+								}
 								that.iActiveContexts = iActiveContexts;
 								that.iCreatedContexts = iCreatedContexts;
-								oCache.setActive(true);
+								for (i = 0; i < iCreatedContexts; i += 1) {
+									aContexts[i].iIndex = i - iCreatedContexts;
+									delete that.mPreviousContextsByPath[aContexts[i].getPath()];
+								}
+								that.aContexts = aContexts; // restore created contexts
 								that._fireChange({reason : ChangeReason.Change});
 							}
 							throw oError;
 						});
+					}).finally(function () {
+						if (oCache.restore) {
+							oCache.restore(false);
+						}
 					});
 				}
 			}
 			// Note: after reset the dependent bindings cannot be found any more
 			aDependentBindings = that.getDependentBindings();
-			that.reset(ChangeReason.Refresh, true); // this may reset that.oRefreshPromise
+			 // this may reset that.oRefreshPromise
+			that.reset(ChangeReason.Refresh, bKeepCacheOnError ? false : undefined);
 			return SyncPromise.all(
 				refreshAll(aDependentBindings).concat(oPromise, oKeptElementsPromise,
 					// Update after refresh event, otherwise $count is fetched before the request
@@ -3014,19 +3148,21 @@ sap.ui.define([
 	 *   A change reason; if given, a refresh event with this reason is fired and the next
 	 *   getContexts() fires a change event with this reason. Change reason "change" is ignored
 	 *   as long as the binding is still empty.
-	 * @param {boolean} [bDropTransient]
-	 *   Whether transient contexts shall also be dropped, not just created persisted ones
+	 * @param {boolean} [bDrop]
+	 *   By default, all created persisted contexts are dropped while transient ones are not.
+	 *   <code>true</code> also drops transient ones, and <code>false</code> keeps created persisted
+	 *   that started as inactive.
 	 *
 	 * @private
 	 */
-	ODataListBinding.prototype.reset = function (sChangeReason, bDropTransient) {
+	ODataListBinding.prototype.reset = function (sChangeReason, bDrop) {
 		var oContext,
 			bEmpty = this.iCurrentEnd === 0,
 			iTransient = 0,
 			i,
 			that = this;
 
-		if (bDropTransient) {
+		if (bDrop === true) { // drop 'em all
 			this.iActiveContexts = 0;
 			this.iCreatedContexts = 0;
 		}
@@ -3036,10 +3172,11 @@ sap.ui.define([
 			});
 			for (i = 0; i < this.iCreatedContexts; i += 1) {
 				oContext = this.aContexts[i];
-				if (oContext.isTransient()) {
+				if (oContext.isTransient()
+						|| bDrop === false && oContext.isInactive() !== undefined) {
 					this.aContexts[iTransient] = oContext;
 					iTransient += 1;
-				} else { // Note: "created persisted" elements must be active
+				} else { // Note: "created persisted" elements must be active - drop 'em
 					this.iActiveContexts -= 1;
 					this.mPreviousContextsByPath[oContext.getPath()] = oContext;
 				}

package/src/sap/ui/model/odata/v4/ODataMetaModel.js

@@ -157,7 +157,7 @@ sap.ui.define([
 		 * @hideconstructor
 		 * @public
 		 * @since 1.37.0
-		 * @version 1.99.0
+		 * @version 1.100.1
 		 */
 		ODataMetaModel = MetaModel.extend("sap.ui.model.odata.v4.ODataMetaModel", {
 				constructor : constructor