@openui5/sap.ui.core 1.96.2 → 1.97.0

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

@@ -98,7 +98,7 @@ sap.ui.define([
 	 * @hideconstructor
 	 * @public
 	 * @since 1.39.0
-	 * @version 1.96.2
+	 * @version 1.97.0
 	 */
 	var Context = BaseContext.extend("sap.ui.model.odata.v4.Context", {
 			constructor : function (oModel, oBinding, sPath, iIndex, oCreatePromise, iGeneration) {
@@ -131,6 +131,9 @@ sap.ui.define([
 	 *   An entity with the ETag of the binding for which the deletion was requested. This is
 	 *   provided if the deletion is delegated from a context binding with empty path to a list
 	 *   binding.
+	 * @param {boolean} [bDoNotRequestCount]
+	 *   Whether not to request the new count from the server; useful in case of
+	 *   {@link #replaceWith} where it is known that the count remains unchanged
 	 * @returns {Promise}
 	 *   A promise which is resolved without a result in case of success, or rejected with an
 	 *   instance of <code>Error</code> in case of failure
@@ -138,14 +141,15 @@ sap.ui.define([
 	 * @private
 	 * @see sap.ui.model.odata.v4.Context#delete
 	 */
-	Context.prototype._delete = function (oGroupLock, oETagEntity) {
+	Context.prototype._delete = function (oGroupLock, oETagEntity, bDoNotRequestCount) {
 		var that = this;
 
 		if (this.isTransient()) {
-			return this.oBinding._delete(oGroupLock, "n/a", this);
+			return this.oBinding._delete(oGroupLock, "n/a", this, bDoNotRequestCount);
 		}
 		return this.fetchCanonicalPath().then(function (sCanonicalPath) {
-			return that.oBinding._delete(oGroupLock, sCanonicalPath.slice(1), that, oETagEntity);
+			return that.oBinding._delete(oGroupLock, sCanonicalPath.slice(1), that, oETagEntity,
+				bDoNotRequestCount);
 		});
 	};
 
@@ -253,6 +257,9 @@ sap.ui.define([
 	 *   the context's binding is used, see {@link #getUpdateGroupId}; the resulting group ID must
 	 *   not have {@link sap.ui.model.odata.v4.SubmitMode.API}. Since 1.81, if this context is
 	 *   transient (see {@link #isTransient}), no group ID needs to be specified.
+	 * @param {boolean} [bDoNotRequestCount]
+	 *   Whether not to request the new count from the server; useful in case of
+	 *   {@link #replaceWith} where it is known that the count remains unchanged (since 1.97.0)
 	 * @returns {Promise}
 	 *   A promise which is resolved without a result in case of success, or rejected with an
 	 *   instance of <code>Error</code> in case of failure, e.g. if the given context does not point
@@ -273,7 +280,7 @@ sap.ui.define([
 	 * @public
 	 * @since 1.41.0
 	 */
-	Context.prototype.delete = function (sGroupId) {
+	Context.prototype.delete = function (sGroupId, bDoNotRequestCount) {
 		var oGroupLock,
 			oModel = this.oModel,
 			that = this;
@@ -287,7 +294,7 @@ sap.ui.define([
 		}
 		oGroupLock = this.oBinding.lockGroup(sGroupId, true, true);
 
-		return this._delete(oGroupLock).then(function () {
+		return this._delete(oGroupLock, /*oETagEntity*/null, bDoNotRequestCount).then(function () {
 			var sResourcePathPrefix = that.sPath.slice(1);
 
 			// Messages have been updated via _Cache#_delete; "that" is already destroyed; remove
@@ -411,7 +418,7 @@ sap.ui.define([
 					return oCache.update(oGroupLock, oResult.propertyPath, vValue,
 						bSkipRetry ? undefined : errorCallback, oResult.editUrl, sEntityPath,
 						oMetaModel.getUnitOrCurrencyPath(that.oModel.resolve(sPath, that)),
-						oBinding.isPatchWithoutSideEffects(), patchSent
+						oBinding.isPatchWithoutSideEffects(), patchSent, that.isKeepAlive.bind(that)
 					).then(function () {
 						firePatchCompleted(true);
 					}, function (oError) {
@@ -898,6 +905,38 @@ sap.ui.define([
 		);
 	};
 
+	/**
+	 * Replaces this context with the given other context. You probably want to delete this context
+	 * afterwards without requesting the new count from the server, see the
+	 * <code>bDoNotRequestCount</code> parameter of {@link #delete}.
+	 *
+	 * @param {sap.ui.model.odata.v4.Context} oOtherContext - The other context
+	 * @throws {Error} If
+	 *   <ul>
+	 *     <li> this context's root binding is suspended,
+	 *     <li> this context is transient (see {@link #isTransient}),
+	 *     <li> the given other context does not belong to the same list binding as this context, or
+	 *       is already in the collection (has an index, see {@link #getIndex}).
+	 *   </ul>
+	 *
+	 * @public
+	 * @since 1.97.0
+	 */
+	Context.prototype.replaceWith = function (oOtherContext) {
+		var oElement;
+
+		this.oBinding.checkSuspended();
+		if (this.isTransient()) {
+			throw new Error("Cannot replace a transient context: " + this);
+		}
+		if (oOtherContext.oBinding !== this.oBinding || oOtherContext.iIndex !== undefined) {
+			throw new Error("Cannot replace with " + oOtherContext);
+		}
+		oElement = oOtherContext.getValue();
+		this.oBinding.doReplaceWith(this, oElement,
+			_Helper.getPrivateAnnotation(oElement, "predicate"));
+	};
+
 	/**
 	 * Returns a promise for the "canonical path" of the entity for this context.
 	 * According to "4.3.1 Canonical URL" of the specification "OData Version 4.0 Part 2: URL
@@ -1344,6 +1383,8 @@ sap.ui.define([
 	 *     <li> a key property of the entity has not been requested,
 	 *     <li> the list binding is relative and does not use the <code>$$ownRequest</code>
 	 *       parameter (see {@link sap.ui.model.odata.v4.ODataModel#bindList}),
+	 *     <li> the list binding uses or inherits the <code>$$sharedRequest</code> parameter
+	 *       (see {@link sap.ui.model.odata.v4.ODataModel#bindList}),
 	 *     <li> the list binding uses data aggregation
 	 *       (see {@link sap.ui.model.odata.v4.ODataListBinding#setAggregation}),
 	 *     <li> messages are requested, but the model does not use the <code>autoExpandSelect</code>

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

@@ -255,12 +255,17 @@ sap.ui.define([
 	 *   The resource path
 	 * @param {sap.ui.model.Context} [oContext]
 	 *   The context instance to be used, undefined for absolute bindings
-	 * @returns {sap.ui.model.odata.lib._Cache}
+	 * @param {boolean} [bOldCacheReadOnly]
+	 *   Whether the old cache is read-only and must be kept intact - not reset and reused!
+	 * @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}
 	 *   The cache
 	 *
 	 * @private
 	 */
-	ODataBinding.prototype.createAndSetCache = function (mQueryOptions, sResourcePath, oContext) {
+	ODataBinding.prototype.createAndSetCache = function (mQueryOptions, sResourcePath, oContext,
+			bOldCacheReadOnly, oOldCache) {
 		var oCache, sDeepResourcePath, iGeneration;
 
 		this.mCacheQueryOptions = Object.assign({}, this.oModel.mUriParameters, mQueryOptions);
@@ -284,7 +289,7 @@ sap.ui.define([
 			} else {
 				sDeepResourcePath = _Helper.buildPath(oContext.getPath(), this.sPath).slice(1);
 				oCache = this.doCreateCache(sResourcePath, this.mCacheQueryOptions, oContext,
-					sDeepResourcePath);
+					sDeepResourcePath, bOldCacheReadOnly, oOldCache);
 				if (!(this.mParameters && this.mParameters.$$sharedRequest)) {
 					this.mCacheByResourcePath = this.mCacheByResourcePath || {};
 					this.mCacheByResourcePath[sResourcePath] = oCache;
@@ -293,10 +298,16 @@ sap.ui.define([
 				oCache.$generation = iGeneration;
 			}
 		} else { // absolute binding
-			oCache = this.doCreateCache(sResourcePath, this.mCacheQueryOptions);
+			oCache = this.doCreateCache(sResourcePath, this.mCacheQueryOptions, undefined,
+				undefined, bOldCacheReadOnly, oOldCache);
 		}
-		if (this.mLateQueryOptions) {
-			oCache.setLateQueryOptions(this.mLateQueryOptions);
+		if (oOldCache !== oCache) {
+			if (oOldCache) {
+				oOldCache.setActive(false);
+			}
+			if (this.mLateQueryOptions) {
+				oCache.setLateQueryOptions(this.mLateQueryOptions);
+			}
 		}
 		this.oCache = oCache;
 
@@ -337,6 +348,10 @@ 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 {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}
 	 *   The new cache instance
 	 *
@@ -387,15 +402,22 @@ 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!
 	 * @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)
 	 *
 	 * @private
 	 */
-	ODataBinding.prototype.fetchCache = function (oContext, bIgnoreParentCache, bKeepQueryOptions) {
+	ODataBinding.prototype.fetchCache = function (oContext, bIgnoreParentCache, bKeepQueryOptions,
+		bKeepCacheOnError) {
 		var oCache = this.oCache,
-			oCallToken = {},
+			oCallToken = {
+				// propagate old cache from first call of fetchCache to the latest call
+				oOldCache : oCache === undefined ? this.oFetchCacheCallToken.oOldCache : oCache
+			},
 			aPromises,
 			that = this;
 
@@ -403,25 +425,21 @@ sap.ui.define([
 			oContext = undefined;
 		}
 
-		if (oCache) {
-			// if oCachePromise is pending no cache will be created because of oFetchCacheCallToken
-			oCache.setActive(false);
-		} else if (bKeepQueryOptions) {
+		if (!oCache && bKeepQueryOptions) {
 			if (oCache === undefined) {
 				throw new Error("Unsupported bKeepQueryOptions while oCachePromise is pending");
 			}
-			this.oFetchCacheCallToken = undefined;
 			return;
 		}
 
 		this.oCache = undefined;
+		this.oFetchCacheCallToken = oCallToken;
 		if (bKeepQueryOptions) {
 			// asynchronously re-create an equivalent cache
 			this.oCachePromise = SyncPromise.resolve(Promise.resolve()).then(function () {
 				return that.createAndSetCache(that.mCacheQueryOptions, oCache.getResourcePath(),
-					oContext);
+					oContext, bKeepCacheOnError, oCache);
 			});
-			this.oFetchCacheCallToken = undefined;
 			return;
 		}
 
@@ -430,7 +448,6 @@ sap.ui.define([
 			this.oModel.oRequestor.ready()
 		];
 		this.mCacheQueryOptions = undefined;
-		this.oFetchCacheCallToken = oCallToken;
 		this.oCachePromise = SyncPromise.all(aPromises).then(function (aResult) {
 			var mQueryOptions = aResult[0].mQueryOptions;
 
@@ -447,7 +464,8 @@ sap.ui.define([
 						oError.canceled = true;
 						throw oError;
 					}
-					return that.createAndSetCache(mQueryOptions, sResourcePath, oContext);
+					return that.createAndSetCache(mQueryOptions, sResourcePath, oContext,
+						bKeepCacheOnError, oCallToken.oOldCache);
 				});
 			}
 			that.oCache = null;
@@ -803,15 +821,23 @@ sap.ui.define([
 	 * parent context path of this binding. If this binding is unresolved (see
 	 * {@link sap.ui.model.Binding#isResolved}), it returns <code>false</code>.
 	 *
+	 * @param {boolean} [bIgnoreKeptAlive]
+	 *   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#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.
 	 * @returns {boolean}
 	 *   <code>true</code> if the binding is resolved and has pending changes
 	 *
 	 * @public
 	 * @since 1.39.0
 	 */
-	ODataBinding.prototype.hasPendingChanges = function () {
+	ODataBinding.prototype.hasPendingChanges = function (bIgnoreKeptAlive) {
 		return this.isResolved()
-			&& (this.hasPendingChangesForPath("") || this.hasPendingChangesInDependents());
+			&& (this.hasPendingChangesForPath("", bIgnoreKeptAlive)
+				|| this.hasPendingChangesInDependents(bIgnoreKeptAlive));
 	};
 
 	/**
@@ -820,20 +846,23 @@ sap.ui.define([
 	 *
 	 * @param {string} sPath
 	 *   The path (absolute or relative to this binding)
+	 * @param {boolean} [bIgnoreKeptAlive]
+	 *   Whether to ignore changes which will not be lost by APIs like sort or filter because they
+	 *   relate to a context which is kept alive.
 	 * @returns {boolean}
 	 *   <code>true</code> if there are pending changes for the path
 	 *
 	 * @private
 	 */
-	ODataBinding.prototype.hasPendingChangesForPath = function (sPath) {
+	ODataBinding.prototype.hasPendingChangesForPath = function (sPath, bIgnoreKeptAlive) {
 		return this.withCache(function (oCache, sCachePath) {
-				return oCache.hasPendingChangesForPath(sCachePath);
+				return oCache.hasPendingChangesForPath(sCachePath, bIgnoreKeptAlive);
 			}, sPath, true).unwrap();
 	};
 
 	/**
 	 * Checks whether there are pending changes in caches stored by resource path at this binding
-	 * which have the given resource path as prefix.
+	 * which have the given resource path as prefix. Called for unresolved bindings only.
 	 *
 	 * @param {string} sResourcePathPrefix
 	 *   The resource path prefix to identify the relevant caches
@@ -861,6 +890,9 @@ sap.ui.define([
 	 *
 	 * @returns {boolean}
 	 *   <code>true</code> if this binding has pending changes
+	 * @param {boolean} [bIgnoreKeptAlive]
+	 *   Whether to ignore changes which will not be lost by APIs like sort or filter because they
+	 *   relate to a context which is kept alive.
 	 *
 	 * @abstract
 	 * @function
@@ -1077,7 +1109,7 @@ sap.ui.define([
 			if (this.requestSideEffects) {
 				return this.requestSideEffects(sGroupId, aPaths);
 			}
-			return this.refreshInternal("", sGroupId, true);
+			return this.refreshInternal("", sGroupId, true, true);
 		}
 		// return undefined;
 	};
@@ -1298,7 +1330,6 @@ sap.ui.define([
 		"adjustPredicate",
 		"destroy",
 		"doDeregisterChangeListener",
-		"fetchCache",
 		"hasPendingChangesForPath"
 	].forEach(function (sMethod) { // method not final, allow for "super" calls
 		asODataBinding.prototype[sMethod] = ODataBinding.prototype[sMethod];

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

@@ -106,7 +106,7 @@ sap.ui.define([
 	 * @mixes sap.ui.model.odata.v4.ODataParentBinding
 	 * @public
 	 * @since 1.37.0
-	 * @version 1.96.2
+	 * @version 1.97.0
 	 *
 	 * @borrows sap.ui.model.odata.v4.ODataBinding#getGroupId as #getGroupId
 	 * @borrows sap.ui.model.odata.v4.ODataBinding#getRootBinding as #getRootBinding
@@ -234,7 +234,7 @@ sap.ui.define([
 			// deleteFromCache call below. In Context#delete the error is reported.
 		}
 
-		return this.deleteFromCache(oGroupLock, sEditUrl, "", undefined, function () {
+		return this.deleteFromCache(oGroupLock, sEditUrl, "", null, false, function () {
 			oEmptyPathParentBinding._destroyContextAfterDelete();
 		});
 	};
@@ -268,6 +268,10 @@ sap.ui.define([
 	 *   actions only
 	 * @param {function} [fnOnStrictHandlingFailed]
 	 *   Callback for strict handling; supported for actions only
+	 * @param {boolean} [bReplaceWithRVC]
+	 *   Whether this operation binding's parent context, which must belong to a list binding, is
+	 *   replaced with the operation's return value context (see below) and that new list context is
+	 *   returned instead. Since 1.97.0.
 	 * @returns {Promise}
 	 *   A promise that is resolved without data or a return value context when the operation call
 	 *   succeeded, or rejected with an instance of <code>Error</code> in case of failure. A return
@@ -280,7 +284,7 @@ sap.ui.define([
 	 * @see #execute for details
 	 */
 	ODataContextBinding.prototype._execute = function (oGroupLock, mParameters, bIgnoreETag,
-			fnOnStrictHandlingFailed) {
+			fnOnStrictHandlingFailed, bReplaceWithRVC) {
 		var oMetaModel = this.oModel.getMetaModel(),
 			oOperationMetadata,
 			oPromise,
@@ -336,12 +340,25 @@ sap.ui.define([
 						if (that.oReturnValueContext) {
 							that.oReturnValueContext.destroy();
 						}
+
+						if (bReplaceWithRVC) {
+							that.oCache = null;
+							that.oCachePromise = SyncPromise.resolve(null);
+
+							return sContextPredicate === sResponsePredicate
+								? that.oContext
+								: that.oContext.getBinding().doReplaceWith(that.oContext,
+									oResponseEntity, sResponsePredicate);
+						}
+
 						that.oReturnValueContext = Context.createNewContext(that.oModel,
 							that, getReturnValueContextPath(sResolvedPath, sResponsePredicate));
 						// set the resource path for late property requests
 						that.oCache.setResourcePath(that.oReturnValueContext.getPath().slice(1));
 
 						return that.oReturnValueContext;
+					} else if (bReplaceWithRVC) {
+						throw new Error("Cannot replace w/o return value context");
 					}
 				});
 			}, function (oError) {
@@ -591,8 +608,7 @@ sap.ui.define([
 	 *    <li> a collection-valued parameter for an operation other than a V4 action is encountered,
 	 *    <li> <code>bIgnoreETag</code> is used for an operation other than a bound action,
 	 *    <li> <code>fnOnStrictHandlingFailed</code> is given but the given metadata is not an
-	 *         "Action",
-	 *    <li> <code>fnOnStrictHandlingFailed</code> is given and it does not return a promise.
+	 *         "Action"
 	 *   </ul>
 	 *
 	 * @private
@@ -815,6 +831,19 @@ sap.ui.define([
 	 *   repeated <b>without</b> applying the preference or rejected with an <code>Error</code>
 	 *   instance <code>oError</code> where <code>oError.canceled === true</code>.
 	 *   Since 1.92.0.
+	 * @param {boolean} [bReplaceWithRVC]
+	 *   Whether this operation binding's parent context, which must belong to a list binding, is
+	 *   replaced with the operation's return value context (see below) and that list context is
+	 *   returned instead. The list context may be a newly created context or an existing context.
+	 *   A newly created context has the same <code>keepAlive</code> attribute and
+	 *   <code>fnOnBeforeDestroy</code> function as the parent context, see
+	 *   {@link sap.ui.model.odata.v4.Context#setKeepAlive}; <code>fnOnBeforeDestroy</code> will be
+	 *   called with the new context instance as the only argument in this case. An existing context
+	 *   does not change its <code>keepAlive</code> attribute. In any case, the resulting context
+	 *   takes the place (index, position) of the parent context
+	 *   {@link sap.ui.model.odata.v4.Context#getIndex}. If the parent context has requested
+	 *   messages when it was kept alive, they will be inherited if the $$inheritExpandSelect
+	 *   binding parameter is set to <code>true</code>. Since 1.97.0.
 	 * @returns {Promise}
 	 *   A promise that is resolved without data or with a return value context when the operation
 	 *   call succeeded, or rejected with an <code>Error</code> instance <code>oError</code> in case
@@ -826,34 +855,45 @@ sap.ui.define([
 	 *    <li> is used for an operation other than an action,
 	 *    <li> another request that applies the preference "handling=strict" exists in a different
 	 *      change set of the same $batch request,
+	 *    <li> it does not return a <code>Promise</code>,
 	 *    <li> returns a <code>Promise</code> that resolves with <code>false</code>. In this case
 	 *      <code>oError.canceled === true</code>.
 	 *   </ul>
+	 *   It is also rejected if <code>bReplaceWithRVC</code> is supplied, and there is no return
+	 *   value context at all or the existing context as described above is currently part of the
+	 *   list's collection (that is, has an index).<br>
 	 *   A return value context is a {@link sap.ui.model.odata.v4.Context} which represents a bound
 	 *   operation response. It is created only if the operation is bound and has a single entity
 	 *   return value from the same entity set as the operation's binding parameter and has a
 	 *   parent context which is a {@link sap.ui.model.odata.v4.Context} and points to an entity
-	 *   from an entity set.
-	 *
+	 *   from an entity set.<br>
 	 *   If a return value context is created, it must be used instead of
 	 *   <code>this.getBoundContext()</code>. All bound messages will be related to the return value
 	 *   context only. Such a message can only be connected to a corresponding control if the
 	 *   control's property bindings use the return value context as binding context.
-	 * @throws {Error} If the binding's root binding is suspended, the given group ID is invalid, if
-	 *   the binding is not a deferred operation binding (see
-	 *   {@link sap.ui.model.odata.v4.ODataContextBinding}), if the binding is unresolved (see
-	 *   {@link sap.ui.model.Binding#isResolved}) or relative to a transient context (see
-	 *   {@link sap.ui.model.odata.v4.Context#isTransient}), or if deferred operation bindings are
-	 *   nested, or if the OData resource path for a deferred operation binding's context cannot be
-	 *   determined, or if <code>fnOnStrictHandlingFailed</code> is called and does not return a
-	 *   <code>Promise</code>.
-
+	 * @throws {Error} If
+	 *   <ul>
+	 *     <li>the binding's root binding is suspended,
+	 *     <li> the given group ID is invalid,
+	 *     <li> the binding is not a deferred operation binding (see
+	 *       {@link sap.ui.model.odata.v4.ODataContextBinding}),
+	 *     <li> the binding is unresolved (see
+	 *       {@link sap.ui.model.Binding#isResolved})
+	 *     <li> the binding is relative to a transient context (see
+	 *       {@link sap.ui.model.odata.v4.Context#isTransient}),
+	 *     <li> deferred operation bindings are nested,
+	 *     <li> the OData resource path for a deferred operation binding's context cannot be
+	 *       determined,
+	 *     <li> <code>bReplaceWithRVC</code> is given, but this operation binding is not relative to
+	 *       a row context of a list binding which uses the <code>$$ownRequest</code> parameter (see
+	 *       {@link sap.ui.model.odata.v4.ODataModel#bindList}) and no data aggregation (see
+	 *       {@link sap.ui.model.odata.v4.ODataListBinding#setAggregation}).
 	 *
 	 * @public
 	 * @since 1.37.0
 	 */
 	ODataContextBinding.prototype.execute = function (sGroupId, bIgnoreETag,
-			fnOnStrictHandlingFailed) {
+			fnOnStrictHandlingFailed, bReplaceWithRVC) {
 		var sResolvedPath = this.getResolvedPath();
 
 		this.checkSuspended();
@@ -872,11 +912,19 @@ sap.ui.define([
 				throw new Error("Nested deferred operation bindings not supported: "
 					+ sResolvedPath);
 			}
+			if (bReplaceWithRVC) {
+				if (!this.oContext.getBinding) {
+					throw new Error("Cannot replace when parent context is not a V4 context");
+				}
+				this.oContext.getBinding().checkKeepAlive(this.oContext);
+			}
+		} else if (bReplaceWithRVC) {
+			throw new Error("Cannot replace when operation is not relative");
 		}
 
 		return this._execute(this.lockGroup(sGroupId, true),
 			_Helper.publicClone(this.oOperation.mParameters, true), bIgnoreETag,
-				fnOnStrictHandlingFailed);
+				fnOnStrictHandlingFailed, bReplaceWithRVC);
 	};
 
 	/**
@@ -1245,7 +1293,7 @@ sap.ui.define([
 				bHasChangeListeners = oCache.hasChangeListeners();
 				// remove all cached Caches before fetching a new one
 				that.removeCachesAndMessages(sResourcePathPrefix);
-				that.fetchCache(that.oContext);
+				that.fetchCache(that.oContext, false, false, bKeepCacheOnError);
 				// Do not fire a change event, or else ManagedObject destroys and recreates the
 				// binding hierarchy causing a flood of events.
 				oPromise = bHasChangeListeners ? that.createRefreshPromise() : undefined;