Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Objects / Internal / EntitySqlQueryState.cs / 1305376 / 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.CommandTrees.ExpressionBuilder;
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()
{
DbExpression query = this.Parse();
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
DbExpression queryExpression = this.Parse();
Debug.Assert(queryExpression != null, "EntitySqlQueryState.Parse returned null expression?");
DbQueryCommandTree tree = DbQueryCommandTree.FromValidExpression(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression);
plan = ObjectQueryExecutionPlan.Prepare(this.ObjectContext, tree, this.ElementType, mergeOption, this.Span, null);
// 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()
{
List parameters = null;
if (this.Parameters != null)
{
parameters = new List(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);
}
Debug.Assert(typeUsage != null, "typeUsage != null");
parameters.Add(typeUsage.Parameter(parameter.Name));
}
}
DbLambda lambda =
CqlQuery.CompileQueryCommandLambda(
_queryText, // Command Text
this.ObjectContext.Perspective, // Perspective
null, // Parser options - null indicates 'use default'
parameters, // Parameters
null // Variables
);
Debug.Assert(lambda.Variables == null || lambda.Variables.Count == 0, "lambda.Variables must be empty");
return lambda.Body;
}
}
}
// 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.CommandTrees.ExpressionBuilder;
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()
{
DbExpression query = this.Parse();
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
DbExpression queryExpression = this.Parse();
Debug.Assert(queryExpression != null, "EntitySqlQueryState.Parse returned null expression?");
DbQueryCommandTree tree = DbQueryCommandTree.FromValidExpression(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression);
plan = ObjectQueryExecutionPlan.Prepare(this.ObjectContext, tree, this.ElementType, mergeOption, this.Span, null);
// 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()
{
List parameters = null;
if (this.Parameters != null)
{
parameters = new List(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);
}
Debug.Assert(typeUsage != null, "typeUsage != null");
parameters.Add(typeUsage.Parameter(parameter.Name));
}
}
DbLambda lambda =
CqlQuery.CompileQueryCommandLambda(
_queryText, // Command Text
this.ObjectContext.Perspective, // Perspective
null, // Parser options - null indicates 'use default'
parameters, // Parameters
null // Variables
);
Debug.Assert(lambda.Variables == null || lambda.Variables.Count == 0, "lambda.Variables must be empty");
return lambda.Body;
}
}
}
// 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
- ColorTransform.cs
- XPathAncestorQuery.cs
- LeftCellWrapper.cs
- DeflateEmulationStream.cs
- EditorZoneBase.cs
- BooleanProjectedSlot.cs
- MessageAction.cs
- WebRequestModuleElement.cs
- HtmlLink.cs
- HttpListenerContext.cs
- ApplicationInfo.cs
- PrefixQName.cs
- UdpChannelFactory.cs
- MouseGestureConverter.cs
- cookieexception.cs
- KeyedHashAlgorithm.cs
- ProfileGroupSettingsCollection.cs
- TraceListener.cs
- ClientUrlResolverWrapper.cs
- DocumentOrderComparer.cs
- Ipv6Element.cs
- TextElementEnumerator.cs
- BinaryMessageFormatter.cs
- CodeTypeDeclaration.cs
- DesignerActionMethodItem.cs
- DateTimeStorage.cs
- PageCatalogPart.cs
- WebDisplayNameAttribute.cs
- PeerNameRegistration.cs
- DateTimePicker.cs
- OlePropertyStructs.cs
- LiteralText.cs
- ListControlDesigner.cs
- SortedList.cs
- ConditionalBranch.cs
- BitmapEffectDrawing.cs
- ObjectDataProvider.cs
- AstTree.cs
- MessageHeader.cs
- HWStack.cs
- assemblycache.cs
- SiteMapSection.cs
- CustomErrorsSection.cs
- SqlCacheDependencyDatabase.cs
- ObjectCache.cs
- DependencyObject.cs
- QuaternionAnimationUsingKeyFrames.cs
- URLString.cs
- DecoderBestFitFallback.cs
- SamlAssertion.cs
- MessageProperties.cs
- SymbolType.cs
- ObjectView.cs
- CodeTypeOfExpression.cs
- SelectedGridItemChangedEvent.cs
- DiscoveryExceptionDictionary.cs
- WSDualHttpBindingCollectionElement.cs
- WindowsToolbarAsMenu.cs
- WeakReferenceEnumerator.cs
- DataContractSet.cs
- NavigationPropertyAccessor.cs
- ASCIIEncoding.cs
- PreparingEnlistment.cs
- ListViewInsertEventArgs.cs
- ByteAnimationBase.cs
- MetafileHeader.cs
- NativeMethodsOther.cs
- hebrewshape.cs
- Int32CAMarshaler.cs
- CheckBoxPopupAdapter.cs
- CapacityStreamGeometryContext.cs
- ParameterToken.cs
- CompilerGlobalScopeAttribute.cs
- XmlElementCollection.cs
- TextParagraphCache.cs
- EntityViewGenerationAttribute.cs
- SqlUserDefinedTypeAttribute.cs
- TypefaceMap.cs
- embossbitmapeffect.cs
- XmlSchemaInferenceException.cs
- ConcurrentQueue.cs
- GrammarBuilderBase.cs
- ConditionalBranch.cs
- EnumerableWrapperWeakToStrong.cs
- OleDbDataAdapter.cs
- SqlCacheDependencyDatabaseCollection.cs
- MouseButtonEventArgs.cs
- VectorAnimationUsingKeyFrames.cs
- SafeNativeMethods.cs
- Invariant.cs
- Descriptor.cs
- ScrollPattern.cs
- DivideByZeroException.cs
- DataGridViewUtilities.cs
- Visitors.cs
- ForAllOperator.cs
- BinaryNegotiation.cs
- WinEventTracker.cs
- ContractSearchPattern.cs
- CallbackHandler.cs