/// <summary> /// Clear out any "compile" state /// </summary> internal void Unprepare() { this._commandDefinition = null; this._preparedCommandTree = null; // Clear the dirty flag on the parameters and parameter collection _parameters.ResetIsDirty(); }
/// <summary> /// Creates a prepared version of this command without regard to the current connection state. /// Called by both <see cref="Prepare"/> and <see cref="ToTraceString"/>. /// </summary> private void InnerPrepare() { // Unprepare if the parameters have changed to force a reprepare if (_parameters.IsDirty) { Unprepare(); } _commandDefinition = GetCommandDefinition(); Debug.Assert(null != _commandDefinition, "_commandDefinition cannot be null"); }
/// <summary> /// Creates a commandDefinition for the command, using the options specified. /// /// Note: This method must not be side-effecting of the command /// </summary> /// <returns>the command definition</returns> private EntityCommandDefinition CreateCommandDefinition() { MakeCommandTree(); // Always check the CQT metadata against the connection metadata (internally, CQT already // validates metadata consistency) if (!_preparedCommandTree.MetadataWorkspace.IsMetadataWorkspaceCSCompatible(this.Connection.GetMetadataWorkspace())) { throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.EntityClient_CommandTreeMetadataIncompatible); } EntityCommandDefinition result = EntityProviderServices.Instance.CreateCommandDefinition(this._connection.StoreProviderFactory, this._preparedCommandTree); return(result); }
/// <summary> /// Constructs a EntityParameter from a CQT parameter. /// </summary> /// <param name="queryParameter"></param> /// <returns></returns> private static EntityParameter CreateEntityParameterFromQueryParameter(KeyValuePair <string, TypeUsage> queryParameter) { // We really can't have a parameter here that isn't a scalar type... Debug.Assert(TypeSemantics.IsScalarType(queryParameter.Value), "Non-scalar type used as query parameter type"); EntityParameter result = new EntityParameter(); result.ParameterName = queryParameter.Key; EntityCommandDefinition.PopulateParameterFromTypeUsage(result, queryParameter.Value, isOutParam: false); return(result); }
public string ToTraceString() { CheckConnectionPresent(); InnerPrepare(); EntityCommandDefinition commandDefinition = _commandDefinition; if (null != commandDefinition) { return(commandDefinition.ToTraceString()); } return(string.Empty); }
/// <summary> /// Gets an entitycommanddefinition from cache if a match is found for the given cache key. /// </summary> /// <param name="entityCommandDefinition">out param. returns the entitycommanddefinition for a given cache key</param> /// <returns>true if a match is found in cache, false otherwise</returns> private bool TryGetEntityCommandDefinitionFromQueryCache(out EntityCommandDefinition entityCommandDefinition) { Debug.Assert(null != _connection, "Connection must not be null at this point"); entityCommandDefinition = null; // // if EnableQueryCaching is false, then just return to force the CommandDefinition to be created // if (!this._enableQueryPlanCaching || string.IsNullOrEmpty(this._esqlCommandText)) { return(false); } // // Create cache key // EntityClientCacheKey queryCacheKey = new EntityClientCacheKey(this); // // Try cache lookup // QueryCacheManager queryCacheManager = _connection.GetMetadataWorkspace().GetQueryCacheManager(); Debug.Assert(null != queryCacheManager, "QuerycacheManager instance cannot be null"); if (!queryCacheManager.TryCacheLookup(queryCacheKey, out entityCommandDefinition)) { // // if not, construct the command definition using no special options; // entityCommandDefinition = CreateCommandDefinition(); // // add to the cache // QueryCacheEntry outQueryCacheEntry = null; if (queryCacheManager.TryLookupAndAdd(new QueryCacheEntry(queryCacheKey, entityCommandDefinition), out outQueryCacheEntry)) { entityCommandDefinition = (EntityCommandDefinition)outQueryCacheEntry.GetTarget(); } } Debug.Assert(null != entityCommandDefinition, "out entityCommandDefinition must not be null"); return(true); }
/// <summary> /// Internal constructor used by EntityCommandDefinition /// </summary> /// <param name="commandDefinition">The prepared command definition that can be executed using this EntityCommand</param> internal EntityCommand(EntityCommandDefinition commandDefinition) : this() { // Assign other member fields from the parameters this._commandDefinition = commandDefinition; this._parameters = new EntityParameterCollection(); // Make copies of the parameters foreach (EntityParameter parameter in commandDefinition.Parameters) { this._parameters.Add(parameter.Clone()); } // Reset the dirty flag that was set to true when the parameters were added so that it won't say // it's dirty to start with this._parameters.ResetIsDirty(); // Track the fact that this command was created from and represents an already prepared command definition this._isCommandDefinitionBased = true; }
/// <summary> /// Get the command definition for the command; will construct one if there is not already /// one constructed, which means it will prepare the command on the client. /// </summary> /// <returns>the command definition</returns> internal EntityCommandDefinition GetCommandDefinition() { EntityCommandDefinition entityCommandDefinition = _commandDefinition; // Construct the command definition using no special options; if (null == entityCommandDefinition) { // // check if the _commandDefinition is in cache // if (!TryGetEntityCommandDefinitionFromQueryCache(out entityCommandDefinition)) { // // if not, construct the command definition using no special options; // entityCommandDefinition = CreateCommandDefinition(); } _commandDefinition = entityCommandDefinition; } return(entityCommandDefinition); }
/// <summary> /// Constructs a new EntityCommand given a EntityConnection and an EntityCommandDefition. This /// constructor is used by ObjectQueryExecution plan to execute an ObjectQuery. /// </summary> /// <param name="connection">The connection against which this EntityCommand should execute</param> /// <param name="commandDefinition">The prepared command definition that can be executed using this EntityCommand</param> internal EntityCommand(EntityConnection connection, EntityCommandDefinition entityCommandDefinition) : this(entityCommandDefinition) { this._connection = connection; }