Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / ndp / fx / src / DataEntity / System / Data / Objects / Internal / EntitySqlQueryState.cs / 1 / EntitySqlQueryState.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
//---------------------------------------------------------------------
using System.Collections.Generic;
using System.Data.Common;
using System.Data.Common.CommandTrees;
using System.Data.Common.EntitySql;
using System.Data.Common.QueryCache;
using System.Data.Common.Utils;
using System.Data.EntityClient;
using System.Data.Metadata.Edm;
using System.Data.Objects.Internal;
using System.Diagnostics;
namespace System.Data.Objects
{
///
/// ObjectQueryState based on Entity-SQL query text.
///
internal sealed class EntitySqlQueryState : ObjectQueryState
{
///
/// The Entity-SQL text that defines the query.
///
private readonly string _queryText;
///
/// Can a Limit subclause be appended to the text of this query?
///
private readonly bool _allowsLimit;
///
/// Initializes a new query EntitySqlQueryState instance.
///
///
/// The ObjectContext containing the metadata workspace the query was
/// built against, the connection on which to execute the query, and the
/// cache to store the results in. Must not be null.
///
///
/// The Entity-SQL text of the query
///
///
/// The merge option to use when retrieving results if an explicit merge option is not specified
///
internal EntitySqlQueryState(Type elementType, string commandText, bool allowsLimit, ObjectContext context, ObjectParameterCollection parameters, Span span)
: base(elementType, context, parameters, span)
{
EntityUtil.CheckArgumentNull(commandText, "commandText");
if (string.IsNullOrEmpty(commandText))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectQuery_InvalidEmptyQuery, "commandText");
}
_queryText = commandText;
_allowsLimit = allowsLimit;
}
///
/// Determines whether or not the current query is a 'Skip' or 'Sort' operation
/// and so would allow a 'Limit' clause to be appended to the current query text.
///
///
/// True if the current query is a Skip or Sort expression, or a
/// Project expression with a Skip or Sort expression input.
///
internal bool AllowsLimitSubclause { get { return _allowsLimit; } }
///
/// Always returns the Entity-SQL text of the implemented ObjectQuery.
///
/// Always set to the Entity-SQL text of this ObjectQuery.
/// Always returns true .
internal override bool TryGetCommandText(out string commandText)
{
commandText = this._queryText;
return true;
}
internal override bool TryGetExpression(out System.Linq.Expressions.Expression expression)
{
expression = null;
return false;
}
protected override TypeUsage GetResultType()
{
DbQueryCommandTree tree = new DbQueryCommandTree(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace);
DbExpression query = this.Parse(tree);
return query.ResultType;
}
internal override ObjectQueryState Include(ObjectQuery sourceQuery, string includePath)
{
ObjectQueryState retState = new EntitySqlQueryState(this.ElementType, _queryText, _allowsLimit, this.ObjectContext, ObjectParameterCollection.DeepCopy(this.Parameters), Span.IncludeIn(this.Span, includePath));
this.ApplySettingsTo(retState);
return retState;
}
internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMergeOption)
{
// Metadata is required to generate the execution plan or to retrieve it from the cache.
this.ObjectContext.EnsureMetadata();
// Determine the required merge option, with the following precedence:
// 1. The merge option specified to Execute(MergeOption) as forMergeOption.
// 2. The merge option set via ObjectQuery.MergeOption.
// 3. The global default merge option.
MergeOption mergeOption = EnsureMergeOption(forMergeOption, this.UserSpecifiedMergeOption);
// If a cached plan is present, then it can be reused if it has the required merge option
// (since span and parameters cannot change between executions). However, if the cached
// plan does not have the required merge option we proceed as if it were not present.
ObjectQueryExecutionPlan plan = this._cachedPlan;
if (plan != null)
{
if (plan.MergeOption == mergeOption)
{
return plan;
}
else
{
plan = null;
}
}
// There is no cached plan (or it was cleared), so the execution plan must be retrieved from
// the global query cache (if plan caching is enabled) or rebuilt for the required merge option.
QueryCacheManager cacheManager = null;
EntitySqlQueryCacheKey cacheKey = null;
if (this.PlanCachingEnabled)
{
// Create a new cache key that reflects the current state of the Parameters collection
// and the Span object (if any), and uses the specified merge option.
cacheKey = new EntitySqlQueryCacheKey(
this.ObjectContext.DefaultContainerName,
_queryText,
(null == this.Parameters ? 0 : this.Parameters.Count),
(null == this.Parameters ? null : this.Parameters.GetCacheKey()),
(null == this.Span ? null : this.Span.GetCacheKey()),
mergeOption,
this.ElementType);
cacheManager = this.ObjectContext.MetadataWorkspace.GetQueryCacheManager();
ObjectQueryExecutionPlan executionPlan = null;
if (cacheManager.TryCacheLookup(cacheKey, out executionPlan))
{
plan = executionPlan;
}
}
if (plan == null)
{
// Either caching is not enabled or the execution plan was not found in the cache
DbQueryCommandTree tree = new DbQueryCommandTree(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace);
tree.Query = this.Parse(tree);
Debug.Assert(tree.Query != null, "EntitySqlQueryState.Parse returned null expression?");
plan = ObjectQueryExecutionPlan.Prepare(this.ObjectContext, tree, this.ElementType, mergeOption, this.Span);
// If caching is enabled then update the cache now
if (cacheKey != null)
{
EntitySqlQueryCacheEntry newEntry = new EntitySqlQueryCacheEntry(cacheKey, plan);
QueryCacheEntry foundEntry = null;
if (cacheManager.TryLookupAndAdd(newEntry, out foundEntry))
{
// If TryLookupAndAdd returns 'true' then the entry was already present in the cache when the attempt to add was made.
// In this case the existing execution plan should be used.
plan = ((EntitySqlQueryCacheEntry)foundEntry).ExecutionPlan;
}
}
}
if (this.Parameters != null)
{
this.Parameters.SetReadOnly(true);
}
// Update the cached plan with the newly retrieved/prepared plan
this._cachedPlan = plan;
// Return the execution plan
return plan;
}
internal DbExpression Parse(DbCommandTree parseTree)
{
Dictionary paramTypes = null;
if (this.Parameters != null)
{
paramTypes = new Dictionary(this.Parameters.Count);
foreach (ObjectParameter parameter in this.Parameters)
{
TypeUsage typeUsage = parameter.TypeUsage;
if (null == typeUsage)
{
// Since ObjectParameters do not allow users to specify 'facets', make
// sure that the parameter TypeUsage is not populated with the provider
// default facet values.
this.ObjectContext.Perspective.TryGetTypeByName(
parameter.MappableType.FullName,
false /* bIgnoreCase */,
out typeUsage);
}
paramTypes.Add(parameter.Name, typeUsage);
}
}
DbExpression expr =
CqlQuery.Compile(
parseTree,
_queryText, // Command Text
this.ObjectContext.Perspective, // Perspective
null, // Parser options - null indicates 'use default'
paramTypes, // Parameters
null // Variables
);
return expr;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
//---------------------------------------------------------------------
using System.Collections.Generic;
using System.Data.Common;
using System.Data.Common.CommandTrees;
using System.Data.Common.EntitySql;
using System.Data.Common.QueryCache;
using System.Data.Common.Utils;
using System.Data.EntityClient;
using System.Data.Metadata.Edm;
using System.Data.Objects.Internal;
using System.Diagnostics;
namespace System.Data.Objects
{
///
/// ObjectQueryState based on Entity-SQL query text.
///
internal sealed class EntitySqlQueryState : ObjectQueryState
{
///
/// The Entity-SQL text that defines the query.
///
private readonly string _queryText;
///
/// Can a Limit subclause be appended to the text of this query?
///
private readonly bool _allowsLimit;
///
/// Initializes a new query EntitySqlQueryState instance.
///
///
/// The ObjectContext containing the metadata workspace the query was
/// built against, the connection on which to execute the query, and the
/// cache to store the results in. Must not be null.
///
///
/// The Entity-SQL text of the query
///
///
/// The merge option to use when retrieving results if an explicit merge option is not specified
///
internal EntitySqlQueryState(Type elementType, string commandText, bool allowsLimit, ObjectContext context, ObjectParameterCollection parameters, Span span)
: base(elementType, context, parameters, span)
{
EntityUtil.CheckArgumentNull(commandText, "commandText");
if (string.IsNullOrEmpty(commandText))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectQuery_InvalidEmptyQuery, "commandText");
}
_queryText = commandText;
_allowsLimit = allowsLimit;
}
///
/// Determines whether or not the current query is a 'Skip' or 'Sort' operation
/// and so would allow a 'Limit' clause to be appended to the current query text.
///
///
/// True if the current query is a Skip or Sort expression, or a
/// Project expression with a Skip or Sort expression input.
///
internal bool AllowsLimitSubclause { get { return _allowsLimit; } }
///
/// Always returns the Entity-SQL text of the implemented ObjectQuery.
///
/// Always set to the Entity-SQL text of this ObjectQuery.
/// Always returns true .
internal override bool TryGetCommandText(out string commandText)
{
commandText = this._queryText;
return true;
}
internal override bool TryGetExpression(out System.Linq.Expressions.Expression expression)
{
expression = null;
return false;
}
protected override TypeUsage GetResultType()
{
DbQueryCommandTree tree = new DbQueryCommandTree(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace);
DbExpression query = this.Parse(tree);
return query.ResultType;
}
internal override ObjectQueryState Include(ObjectQuery sourceQuery, string includePath)
{
ObjectQueryState retState = new EntitySqlQueryState(this.ElementType, _queryText, _allowsLimit, this.ObjectContext, ObjectParameterCollection.DeepCopy(this.Parameters), Span.IncludeIn(this.Span, includePath));
this.ApplySettingsTo(retState);
return retState;
}
internal override ObjectQueryExecutionPlan GetExecutionPlan(MergeOption? forMergeOption)
{
// Metadata is required to generate the execution plan or to retrieve it from the cache.
this.ObjectContext.EnsureMetadata();
// Determine the required merge option, with the following precedence:
// 1. The merge option specified to Execute(MergeOption) as forMergeOption.
// 2. The merge option set via ObjectQuery.MergeOption.
// 3. The global default merge option.
MergeOption mergeOption = EnsureMergeOption(forMergeOption, this.UserSpecifiedMergeOption);
// If a cached plan is present, then it can be reused if it has the required merge option
// (since span and parameters cannot change between executions). However, if the cached
// plan does not have the required merge option we proceed as if it were not present.
ObjectQueryExecutionPlan plan = this._cachedPlan;
if (plan != null)
{
if (plan.MergeOption == mergeOption)
{
return plan;
}
else
{
plan = null;
}
}
// There is no cached plan (or it was cleared), so the execution plan must be retrieved from
// the global query cache (if plan caching is enabled) or rebuilt for the required merge option.
QueryCacheManager cacheManager = null;
EntitySqlQueryCacheKey cacheKey = null;
if (this.PlanCachingEnabled)
{
// Create a new cache key that reflects the current state of the Parameters collection
// and the Span object (if any), and uses the specified merge option.
cacheKey = new EntitySqlQueryCacheKey(
this.ObjectContext.DefaultContainerName,
_queryText,
(null == this.Parameters ? 0 : this.Parameters.Count),
(null == this.Parameters ? null : this.Parameters.GetCacheKey()),
(null == this.Span ? null : this.Span.GetCacheKey()),
mergeOption,
this.ElementType);
cacheManager = this.ObjectContext.MetadataWorkspace.GetQueryCacheManager();
ObjectQueryExecutionPlan executionPlan = null;
if (cacheManager.TryCacheLookup(cacheKey, out executionPlan))
{
plan = executionPlan;
}
}
if (plan == null)
{
// Either caching is not enabled or the execution plan was not found in the cache
DbQueryCommandTree tree = new DbQueryCommandTree(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace);
tree.Query = this.Parse(tree);
Debug.Assert(tree.Query != null, "EntitySqlQueryState.Parse returned null expression?");
plan = ObjectQueryExecutionPlan.Prepare(this.ObjectContext, tree, this.ElementType, mergeOption, this.Span);
// If caching is enabled then update the cache now
if (cacheKey != null)
{
EntitySqlQueryCacheEntry newEntry = new EntitySqlQueryCacheEntry(cacheKey, plan);
QueryCacheEntry foundEntry = null;
if (cacheManager.TryLookupAndAdd(newEntry, out foundEntry))
{
// If TryLookupAndAdd returns 'true' then the entry was already present in the cache when the attempt to add was made.
// In this case the existing execution plan should be used.
plan = ((EntitySqlQueryCacheEntry)foundEntry).ExecutionPlan;
}
}
}
if (this.Parameters != null)
{
this.Parameters.SetReadOnly(true);
}
// Update the cached plan with the newly retrieved/prepared plan
this._cachedPlan = plan;
// Return the execution plan
return plan;
}
internal DbExpression Parse(DbCommandTree parseTree)
{
Dictionary paramTypes = null;
if (this.Parameters != null)
{
paramTypes = new Dictionary(this.Parameters.Count);
foreach (ObjectParameter parameter in this.Parameters)
{
TypeUsage typeUsage = parameter.TypeUsage;
if (null == typeUsage)
{
// Since ObjectParameters do not allow users to specify 'facets', make
// sure that the parameter TypeUsage is not populated with the provider
// default facet values.
this.ObjectContext.Perspective.TryGetTypeByName(
parameter.MappableType.FullName,
false /* bIgnoreCase */,
out typeUsage);
}
paramTypes.Add(parameter.Name, typeUsage);
}
}
DbExpression expr =
CqlQuery.Compile(
parseTree,
_queryText, // Command Text
this.ObjectContext.Perspective, // Perspective
null, // Parser options - null indicates 'use default'
paramTypes, // Parameters
null // Variables
);
return expr;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- TableChangeProcessor.cs
- InternalTransaction.cs
- DataGridColumn.cs
- DocumentOutline.cs
- FragmentQuery.cs
- UnauthorizedWebPart.cs
- ApplicationSettingsBase.cs
- Timer.cs
- XmlLoader.cs
- DeclaredTypeElement.cs
- RootBrowserWindowAutomationPeer.cs
- PageClientProxyGenerator.cs
- ProcessModelInfo.cs
- ScrollItemPattern.cs
- FtpWebResponse.cs
- DataBinding.cs
- EntityDataSourceSelectedEventArgs.cs
- ChangeProcessor.cs
- PropertyGroupDescription.cs
- FrameworkElementFactoryMarkupObject.cs
- Type.cs
- RuleProcessor.cs
- WmlValidatorAdapter.cs
- UnSafeCharBuffer.cs
- ErrorStyle.cs
- ItemContainerGenerator.cs
- ConnectionsZone.cs
- PassportAuthentication.cs
- FullTextState.cs
- DataGridViewRowPrePaintEventArgs.cs
- DataGridViewAccessibleObject.cs
- ScrollEvent.cs
- ObjectDataSourceSelectingEventArgs.cs
- DateTimeUtil.cs
- Match.cs
- RightsManagementPermission.cs
- ResourcePermissionBase.cs
- ListControlActionList.cs
- Marshal.cs
- TaskFormBase.cs
- KeyValueConfigurationElement.cs
- PropertyItem.cs
- XPathNodeList.cs
- SamlDoNotCacheCondition.cs
- InputLanguageEventArgs.cs
- FunctionUpdateCommand.cs
- DynamicActivity.cs
- GuidelineSet.cs
- Header.cs
- Point3DConverter.cs
- DataViewListener.cs
- Control.cs
- IdentityReference.cs
- TreeNode.cs
- IUnknownConstantAttribute.cs
- GeometryGroup.cs
- PeerDuplexChannel.cs
- ActiveXHost.cs
- WindowsGraphicsWrapper.cs
- OverflowException.cs
- Cursor.cs
- XmlNamespaceManager.cs
- Cursors.cs
- TTSVoice.cs
- HTTPNotFoundHandler.cs
- AlphabetConverter.cs
- MessageQueueKey.cs
- ISessionStateStore.cs
- Parameter.cs
- NamespaceListProperty.cs
- _HelperAsyncResults.cs
- SqlProviderManifest.cs
- ClientTargetSection.cs
- HostExecutionContextManager.cs
- NativeWindow.cs
- DataTableExtensions.cs
- LoginViewDesigner.cs
- HTTPRemotingHandler.cs
- StringCollection.cs
- CodeDOMProvider.cs
- XmlQueryType.cs
- FunctionOverloadResolver.cs
- DynamicDataRouteHandler.cs
- AxisAngleRotation3D.cs
- Context.cs
- TextEffectResolver.cs
- OdbcCommandBuilder.cs
- DataTableClearEvent.cs
- GregorianCalendarHelper.cs
- GiveFeedbackEvent.cs
- StorageConditionPropertyMapping.cs
- NonVisualControlAttribute.cs
- StateBag.cs
- ListBoxItem.cs
- TransformCollection.cs
- DefaultClaimSet.cs
- XmlObjectSerializerWriteContext.cs
- DelayedRegex.cs
- TypeUtil.cs
- PanelDesigner.cs