internal static ObjectQueryExecutionPlan Prepare(ObjectContext context, DbQueryCommandTree tree, Type elementType, MergeOption mergeOption, Span span, CompiledQueryParameters compiledQueryParameters, AliasGenerator aliasGenerator)
{
TypeUsage treeResultType = tree.Query.ResultType;
// Rewrite this tree for Span?
DbExpression spannedQuery = null;
SpanIndex spanInfo;
if (ObjectSpanRewriter.TryRewrite(tree, span, mergeOption, aliasGenerator, out spannedQuery, out spanInfo))
{
tree = DbQueryCommandTree.FromValidExpression(tree.MetadataWorkspace, tree.DataSpace, spannedQuery);
}
else
{
spanInfo = null;
}
DbConnection connection = context.Connection;
DbCommandDefinition definition = null;
// The connection is required to get to the CommandDefinition builder.
if (connection == null)
{
throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectQuery_InvalidConnection);
}
DbProviderServices services = DbProviderServices.GetProviderServices(connection);
try
{
definition = services.CreateCommandDefinition(tree);
}
catch (EntityCommandCompilationException)
{
// If we're running against EntityCommand, we probably already caught the providers'
// exception and wrapped it, we don't want to do that again, so we'll just rethrow
// here instead.
throw;
}
catch (Exception e)
{
// we should not be wrapping all exceptions
if (EntityUtil.IsCatchableExceptionType(e))
{
// we don't wan't folks to have to know all the various types of exceptions that can
// occur, so we just rethrow a CommandDefinitionException and make whatever we caught
// the inner exception of it.
throw EntityUtil.CommandCompilation(System.Data.Entity.Strings.EntityClient_CommandDefinitionPreparationFailed, e);
}
throw;
}
if (definition == null)
{
throw EntityUtil.ProviderDoesNotSupportCommandTrees();
}
EntityCommandDefinition entityDefinition = (EntityCommandDefinition)definition;
QueryCacheManager cacheManager = context.Perspective.MetadataWorkspace.GetQueryCacheManager();
ShaperFactory shaperFactory = ShaperFactory.Create(elementType, cacheManager, entityDefinition.CreateColumnMap(null),
context.MetadataWorkspace, spanInfo, mergeOption, false);
// attempt to determine entity information for this query (e.g. which entity type and which entity set)
//EntityType rootEntityType = null;
EntitySet singleEntitySet = null;
if (treeResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.CollectionType)
{
// determine if the entity set is unambiguous given the entity type
if (null != entityDefinition.EntitySets)
{
foreach (EntitySet entitySet in entityDefinition.EntitySets)
{
if (null != entitySet)
{
if (entitySet.ElementType.IsAssignableFrom(((CollectionType)treeResultType.EdmType).TypeUsage.EdmType))
{
if (singleEntitySet == null)
{
// found a single match
singleEntitySet = entitySet;
}
else
{
// there's more than one matching entity set
singleEntitySet = null;
break;
}
}
}
}
}
}
return(new ObjectQueryExecutionPlan(definition, shaperFactory, treeResultType, mergeOption, singleEntitySet, compiledQueryParameters));
}
/// <summary>
/// don't let this be constructed publicly;
/// </summary>
/// <exception cref="EntityCommandCompilationException">Cannot prepare the command definition for execution; consult the InnerException for more information.</exception>
/// <exception cref="NotSupportedException">The ADO.NET Data Provider you are using does not support CommandTrees.</exception>
internal EntityCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree)
{
EntityUtil.CheckArgumentNull(storeProviderFactory, "storeProviderFactory");
EntityUtil.CheckArgumentNull(commandTree, "commandTree");
DbProviderServices storeProviderServices = DbProviderServices.GetProviderServices(storeProviderFactory);
try {
if (DbCommandTreeKind.Query == commandTree.CommandTreeKind)
{
// Next compile the plan for the command tree
List <ProviderCommandInfo> mappedCommandList = new List <ProviderCommandInfo>();
ColumnMap columnMap;
int columnCount;
PlanCompiler.Compile(commandTree, out mappedCommandList, out columnMap, out columnCount, out _entitySets);
_columnMapGenerators = new IColumnMapGenerator[] { new ConstantColumnMapGenerator(columnMap, columnCount) };
// Note: we presume that the first item in the ProviderCommandInfo is the root node;
Debug.Assert(mappedCommandList.Count > 0, "empty providerCommandInfo collection and no exception?"); // this shouldn't ever happen.
// Then, generate the store commands from the resulting command tree(s)
_mappedCommandDefinitions = new List <DbCommandDefinition>(mappedCommandList.Count);
foreach (ProviderCommandInfo providerCommandInfo in mappedCommandList)
{
DbCommandDefinition providerCommandDefinition = storeProviderServices.CreateCommandDefinition(providerCommandInfo.CommandTree);
if (null == providerCommandDefinition)
{
throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.ProviderReturnedNullForCreateCommandDefinition);
}
_mappedCommandDefinitions.Add(providerCommandDefinition);
}
}
else
{
Debug.Assert(DbCommandTreeKind.Function == commandTree.CommandTreeKind, "only query and function command trees are supported");
DbFunctionCommandTree entityCommandTree = (DbFunctionCommandTree)commandTree;
// Retrieve mapping and metadata information for the function import.
FunctionImportMappingNonComposable mapping = GetTargetFunctionMapping(entityCommandTree);
IList <FunctionParameter> returnParameters = entityCommandTree.EdmFunction.ReturnParameters;
int resultSetCount = returnParameters.Count > 1 ? returnParameters.Count : 1;
_columnMapGenerators = new IColumnMapGenerator[resultSetCount];
TypeUsage storeResultType = DetermineStoreResultType(entityCommandTree.MetadataWorkspace, mapping, 0, out _columnMapGenerators[0]);
for (int i = 1; i < resultSetCount; i++)
{
DetermineStoreResultType(entityCommandTree.MetadataWorkspace, mapping, i, out _columnMapGenerators[i]);
}
// Copy over parameters (this happens through a more indirect route in the plan compiler, but
// it happens nonetheless)
List <KeyValuePair <string, TypeUsage> > providerParameters = new List <KeyValuePair <string, TypeUsage> >();
foreach (KeyValuePair <string, TypeUsage> parameter in entityCommandTree.Parameters)
{
providerParameters.Add(parameter);
}
// Construct store command tree usage.
DbFunctionCommandTree providerCommandTree = new DbFunctionCommandTree(entityCommandTree.MetadataWorkspace, DataSpace.SSpace,
mapping.TargetFunction, storeResultType, providerParameters);
DbCommandDefinition storeCommandDefinition = storeProviderServices.CreateCommandDefinition(providerCommandTree);
_mappedCommandDefinitions = new List <DbCommandDefinition>(1)
{
storeCommandDefinition
};
EntitySet firstResultEntitySet = mapping.FunctionImport.EntitySets.FirstOrDefault();
if (firstResultEntitySet != null)
{
_entitySets = new Set <EntitySet>();
_entitySets.Add(mapping.FunctionImport.EntitySets.FirstOrDefault());
_entitySets.MakeReadOnly();
}
}
// Finally, build a list of the parameters that the resulting command should have;
List <EntityParameter> parameterList = new List <EntityParameter>();
foreach (KeyValuePair <string, TypeUsage> queryParameter in commandTree.Parameters)
{
EntityParameter parameter = CreateEntityParameterFromQueryParameter(queryParameter);
parameterList.Add(parameter);
}
_parameters = new System.Collections.ObjectModel.ReadOnlyCollection <EntityParameter>(parameterList);
}
catch (EntityCommandCompilationException) {
// No need to re-wrap EntityCommandCompilationException
throw;
}
catch (Exception e) {
// we should not be wrapping all exceptions
if (EntityUtil.IsCatchableExceptionType(e))
{
// we don't wan't folks to have to know all the various types of exceptions that can
// occur, so we just rethrow a CommandDefinitionException and make whatever we caught
// the inner exception of it.
throw EntityUtil.CommandCompilation(System.Data.Entity.Strings.EntityClient_CommandDefinitionPreparationFailed, e);
}
throw;
}
}