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
- Button.cs
- CrossAppDomainChannel.cs
- XmlQualifiedName.cs
- SocketPermission.cs
- CacheRequest.cs
- HtmlImageAdapter.cs
- SemanticTag.cs
- MarkupCompiler.cs
- Configuration.cs
- QilTargetType.cs
- VSWCFServiceContractGenerator.cs
- ContextDataSource.cs
- UndoUnit.cs
- StreamUpdate.cs
- QueueProcessor.cs
- Speller.cs
- WorkerRequest.cs
- FlowSwitch.cs
- SectionInput.cs
- AnnotationAuthorChangedEventArgs.cs
- AuthenticationManager.cs
- ToolStripStatusLabel.cs
- SchemaImporter.cs
- SectionVisual.cs
- GridViewItemAutomationPeer.cs
- AssemblyBuilder.cs
- GenerateTemporaryTargetAssembly.cs
- DataServiceExpressionVisitor.cs
- HtmlInputHidden.cs
- ArgumentNullException.cs
- Operand.cs
- MetroSerializationManager.cs
- AllMembershipCondition.cs
- WmlListAdapter.cs
- IndexedString.cs
- TextSchema.cs
- FixedSOMLineCollection.cs
- PenThreadPool.cs
- XmlCollation.cs
- GradientBrush.cs
- FileRecordSequence.cs
- clipboard.cs
- Predicate.cs
- NetSectionGroup.cs
- TextServicesCompartmentEventSink.cs
- FileSystemWatcher.cs
- MimeTypeAttribute.cs
- ComboBoxRenderer.cs
- SignedXml.cs
- LicenseProviderAttribute.cs
- securitycriticaldata.cs
- ComponentEditorForm.cs
- CodeAccessSecurityEngine.cs
- ThreadExceptionEvent.cs
- PolyBezierSegment.cs
- InternalsVisibleToAttribute.cs
- DataPointer.cs
- AutomationPropertyInfo.cs
- AspProxy.cs
- XPathNavigator.cs
- Table.cs
- StringAnimationBase.cs
- HwndProxyElementProvider.cs
- AssertFilter.cs
- EntityCommandDefinition.cs
- WebPartConnectionsConfigureVerb.cs
- ScrollPattern.cs
- Base64WriteStateInfo.cs
- HtmlTextViewAdapter.cs
- InteropAutomationProvider.cs
- AttachedPropertyBrowsableForChildrenAttribute.cs
- AppearanceEditorPart.cs
- ClientUrlResolverWrapper.cs
- VisualBrush.cs
- ClientRoleProvider.cs
- FileChangesMonitor.cs
- EventTrigger.cs
- DataGridRowClipboardEventArgs.cs
- Margins.cs
- PersonalizationEntry.cs
- PolyBezierSegment.cs
- DataSourceControlBuilder.cs
- OdbcParameter.cs
- HwndSubclass.cs
- ZipIORawDataFileBlock.cs
- Filter.cs
- ScrollItemPattern.cs
- PixelFormatConverter.cs
- SecurityCriticalDataForSet.cs
- ZipIOEndOfCentralDirectoryBlock.cs
- Simplifier.cs
- NetMsmqSecurity.cs
- IPPacketInformation.cs
- InternalBase.cs
- thaishape.cs
- WebPartCatalogAddVerb.cs
- UnsafeNativeMethods.cs
- SignedXml.cs
- XmlNodeComparer.cs
- InvokeBinder.cs