Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Map / ViewGeneration / ViewGenerator.cs / 1305376 / ViewGenerator.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Data.Common.Utils;
using System.Data.Common.Utils.Boolean;
using System.Data.Mapping.ViewGeneration.Structures;
using System.Data.Mapping.ViewGeneration.Validation;
using System.Data.Mapping.ViewGeneration.QueryRewriting;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Data.Mapping.ViewGeneration.Utils;
using System.Data.Metadata.Edm;
using System.Linq;
namespace System.Data.Mapping.ViewGeneration
{
using ViewSet = KeyToListMap;
using CellGroup = Set;
using WrapperBoolExpr = BoolExpr;
using WrapperTrueExpr = TrueExpr;
using WrapperFalseExpr = FalseExpr;
using WrapperNotExpr = NotExpr;
using WrapperOrExpr = OrExpr;
// This class is responsible for generating query or update mapping
// views from the initial cells.
internal class ViewGenerator : InternalBase
{
#region Fields
private CellGroup m_cellGroup; // The initial cells from which we produce views
private ConfigViewGenerator m_config; // Configuration variables
private MemberDomainMap m_queryDomainMap;
private MemberDomainMap m_updateDomainMap;
private Dictionary m_queryRewriterCache;
private List m_foreignKeyConstraints;
private StorageEntityContainerMapping m_entityContainerMapping;
#endregion
#region Internal API - Only Gatekeeper calls it
// effects: Creates a ViewGenerator object that is capable of
// producing query or update mapping views given the relevant schema
// given the "cells"
internal ViewGenerator(CellGroup cellGroup, ConfigViewGenerator config,
List foreignKeyConstraints,
StorageEntityContainerMapping entityContainerMapping)
{
m_cellGroup = cellGroup;
m_config = config;
m_queryRewriterCache = new Dictionary();
m_foreignKeyConstraints = foreignKeyConstraints;
m_entityContainerMapping = entityContainerMapping;
Dictionary> inheritanceGraph = MetadataHelper.BuildUndirectedGraphOfTypes(entityContainerMapping.StorageMappingItemCollection.EdmItemCollection);
SetConfiguration(entityContainerMapping);
// We fix all the cells at this point
m_queryDomainMap = new MemberDomainMap(ViewTarget.QueryView, m_config.IsValidationEnabled, cellGroup, entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, m_config, inheritanceGraph);
m_updateDomainMap = new MemberDomainMap(ViewTarget.UpdateView, m_config.IsValidationEnabled, cellGroup, entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, m_config, inheritanceGraph);
// We now go and fix the queryDomain map so that it has all the
// values from the S-side as well -- this is needed for domain
// constraint propagation, i.e., values from the S-side get
// propagated to te oneOfConst on the C-side. So we better get
// the "possiblveValues" stuff to contain those constants as well
MemberDomainMap.PropagateUpdateDomainToQueryDomain(cellGroup, m_queryDomainMap, m_updateDomainMap);
UpdateWhereClauseForEachCell(cellGroup, m_queryDomainMap, m_updateDomainMap, m_config);
// We need to simplify cell queries, yet we don't want the conditions to disappear
// So, add an extra value to the domain, temporarily
MemberDomainMap queryOpenDomain = m_queryDomainMap.GetOpenDomain();
MemberDomainMap updateOpenDomain = m_updateDomainMap.GetOpenDomain();
// Make sure the WHERE clauses of the cells reflect the changes
foreach (Cell cell in cellGroup)
{
cell.CQuery.WhereClause.FixDomainMap(queryOpenDomain);
cell.SQuery.WhereClause.FixDomainMap(updateOpenDomain);
cell.CQuery.WhereClause.ExpensiveSimplify();
cell.SQuery.WhereClause.ExpensiveSimplify();
cell.CQuery.WhereClause.FixDomainMap(m_queryDomainMap);
cell.SQuery.WhereClause.FixDomainMap(m_updateDomainMap);
}
}
private void SetConfiguration(StorageEntityContainerMapping entityContainerMapping)
{
m_config.IsValidationEnabled = entityContainerMapping.Validate;
m_config.GenerateUpdateViews = entityContainerMapping.GenerateUpdateViews;
}
// effects: Generates views for the particular cellgroup in this. Returns an
// error log describing the errors that were encountered (if none
// were encountered, the ErrorLog.Count is 0). Places the generated
// views in result
internal ErrorLog GenerateAllBidirectionalViews(ViewSet views, CqlIdentifiers identifiers)
{
// Allow missing attributes for now to make entity splitting run through
// we cannot do this for query views in general: need to obtain the exact enumerated domain
if (m_config.IsNormalTracing)
{
StringBuilder builder = new StringBuilder();
Cell.CellsToBuilder(builder, m_cellGroup);
Helpers.StringTraceLine(builder.ToString());
}
m_config.SetTimeForFinishedActivity(PerfType.CellCreation);
// Check if the cellgroup is consistent and all known S constraints are
// satisified by the known C constraints
CellGroupValidator validator = new CellGroupValidator(m_cellGroup, m_config);
ErrorLog errorLog = validator.Validate();
if (errorLog.Count > 0)
{
errorLog.PrintTrace();
return errorLog;
}
m_config.SetTimeForFinishedActivity(PerfType.KeyConstraint);
// We generate update views first since they perform the main
// validation checks
if (m_config.GenerateUpdateViews)
{
errorLog = GenerateDirectionalViews(ViewTarget.UpdateView, identifiers, views);
if (errorLog.Count > 0)
{
return errorLog; // If we have discovered errors here, do not generate query views
}
}
// Make sure that the foreign key constraints are not violated
if (m_config.IsValidationEnabled)
{
CheckForeignKeyConstraints(errorLog);
}
m_config.SetTimeForFinishedActivity(PerfType.ForeignConstraint);
if (errorLog.Count > 0)
{
errorLog.PrintTrace();
return errorLog; // If we have discovered errors here, do not generate query views
}
// Query views - do not allow missing attributes
// For the S-side, we add NOT ... for each scalar constant so
// that if we have C, P in the mapping but the store has C, P, S,
// we can handle it in the query views
m_updateDomainMap.ExpandDomainsToIncludeAllPossibleValues();
errorLog = GenerateDirectionalViews(ViewTarget.QueryView, identifiers, views);
return errorLog;
}
internal ErrorLog GenerateQueryViewForSingleExtent(ViewSet views, CqlIdentifiers identifiers, EntitySetBase entity, EntityTypeBase type, ViewGenerationMode mode)
{
Debug.Assert(mode != ViewGenerationMode.GenerateAllViews);
if (m_config.IsNormalTracing)
{
StringBuilder builder = new StringBuilder();
Cell.CellsToBuilder(builder, m_cellGroup);
Helpers.StringTraceLine(builder.ToString());
}
// Check if the cellgroup is consistent and all known S constraints are
// satisified by the known C constraints
CellGroupValidator validator = new CellGroupValidator(m_cellGroup, m_config);
ErrorLog errorLog = validator.Validate();
if (errorLog.Count > 0)
{
errorLog.PrintTrace();
return errorLog;
}
// Make sure that the foreign key constraints are not violated
if (m_config.IsValidationEnabled)
{
CheckForeignKeyConstraints(errorLog);
}
if (errorLog.Count > 0)
{
errorLog.PrintTrace();
return errorLog; // If we have discovered errors here, do not generate query views
}
// For the S-side, we add NOT ... for each scalar constant so
// that if we have C, P in the mapping but the store has C, P, S,
// we can handle it in the query views
m_updateDomainMap.ExpandDomainsToIncludeAllPossibleValues();
foreach (Cell cell in m_cellGroup)
{
cell.SQuery.WhereClause.FixDomainMap(m_updateDomainMap);
}
errorLog = GenerateQueryViewForExtentAndType(m_entityContainerMapping, identifiers, views, entity, type, mode);
return errorLog;
}
#endregion
#region Private Methods
// effects: Given the extent cells and a map for the domains of all
// variables in it, fixes the cell constant domains of the where
// clauses in the left queries of cells (left is defined using viewTarget)
private static void UpdateWhereClauseForEachCell(IEnumerable extentCells, MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap, ConfigViewGenerator config)
{
foreach (Cell cell in extentCells)
{
cell.CQuery.UpdateWhereClause(queryDomainMap);
cell.SQuery.UpdateWhereClause(updateDomainMap);
}
// Fix domains of enumerated and boolean types -- i.e., whose domains are enumerable
queryDomainMap.ReduceDomainOfEnumerableToEnumeratedValues(ViewTarget.QueryView, config);
updateDomainMap.ReduceDomainOfEnumerableToEnumeratedValues(ViewTarget.UpdateView, config);
}
private ErrorLog GenerateQueryViewForExtentAndType(StorageEntityContainerMapping entityContainerMapping, CqlIdentifiers identifiers, ViewSet views, EntitySetBase entity, EntityTypeBase type, ViewGenerationMode mode)
{
Debug.Assert(mode != ViewGenerationMode.GenerateAllViews);
// Keep track of the mapping exceptions that we have generated
ErrorLog errorLog = new ErrorLog();
if (m_config.IsViewTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
Helpers.FormatTraceLine("================= Generating {0} Query View for: {1} ===========================",
(mode == ViewGenerationMode.OfTypeViews) ? "OfType" : "OfTypeOnly",
entity.Name);
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
}
try
{
// (1) view generation (checks that extents are fully mapped)
ViewgenContext context = CreateViewgenContext(entity, ViewTarget.QueryView, identifiers);
QueryRewriter queryRewriter = GenerateViewsForExtentAndType(type, context, identifiers, views, mode);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
errorLog.Merge(exception.ErrorLog);
}
return errorLog;
}
// requires: schema refers to C-side or S-side schema for the cells
// inside this. if schema.IsQueryView is true, the left side of cells refers
// to the C side (and vice-versa for the right side)
// effects: Generates the relevant views for the schema side and
// returns them. If allowMissingAttributes is true and attributes
// are missing on the schema side, substitutes them with NULL
// Modifies views to contain the generated views for different
// extents specified by cells and the the schemaContext
private ErrorLog GenerateDirectionalViews(ViewTarget viewTarget, CqlIdentifiers identifiers, ViewSet views)
{
bool isQueryView = viewTarget == ViewTarget.QueryView;
// Create an object that partition cells by extent
KeyToListMap extentCellMap = GroupCellsByExtent(m_cellGroup, viewTarget);
// Keep track of the mapping exceptions that we have generated
ErrorLog errorLog = new ErrorLog();
// Generate views for each extent
foreach (EntitySetBase extent in extentCellMap.Keys)
{
if (m_config.IsViewTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
Helpers.FormatTraceLine("================= Generating {0} View for: {1} ===========================",
isQueryView ? "Query" : "Update", extent.Name);
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
}
try
{
// (1) view generation (checks that extents are fully mapped)
QueryRewriter queryRewriter = GenerateDirectionalViewsForExtent(viewTarget, extent, identifiers, views);
// (2) validation for update views
if (viewTarget == ViewTarget.UpdateView &&
m_config.IsValidationEnabled)
{
if (m_config.IsViewTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
Helpers.FormatTraceLine("----------------- Validation for generated update view for: {0} -----------------",
extent.Name);
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
}
RewritingValidator validator = new RewritingValidator(queryRewriter.ViewgenContext, queryRewriter.BasicView);
validator.Validate();
}
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0,
"Incorrectly created mapping exception");
errorLog.Merge(exception.ErrorLog);
}
}
return errorLog;
}
// effects: Generates a view for an extent "extent" that belongs to
// schema "schema". extentCells are the cells for this extent.
// Adds the view corrsponding to the extent to "views"
private QueryRewriter GenerateDirectionalViewsForExtent(ViewTarget viewTarget, EntitySetBase extent, CqlIdentifiers identifiers, ViewSet views)
{
// First normalize the cells in terms of multiconstants, etc
// and then generate the view for the extent
ViewgenContext context = CreateViewgenContext(extent, viewTarget, identifiers);
QueryRewriter queryRewriter = null;
if (m_config.GenerateViewsForEachType)
{
// generate views for each OFTYPE(Extent, Type) combination
foreach (EdmType type in MetadataHelper.GetTypeAndSubtypesOf(extent.ElementType, m_entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, false /*includeAbstractTypes*/))
{
if (m_config.IsViewTracing && false == type.Equals(extent.ElementType))
{
Helpers.FormatTraceLine("CQL View for {0} and type {1}", extent.Name, type.Name);
}
queryRewriter = GenerateViewsForExtentAndType(type, context, identifiers, views, ViewGenerationMode.OfTypeViews);
}
}
else
{
// generate the view for Extent only
queryRewriter = GenerateViewsForExtentAndType(extent.ElementType, context, identifiers, views, ViewGenerationMode.OfTypeViews);
}
if (viewTarget == ViewTarget.QueryView)
{
m_config.SetTimeForFinishedActivity(PerfType.QueryViews);
}
else
{
m_config.SetTimeForFinishedActivity(PerfType.UpdateViews);
}
// cache this rewriter (and context inside it) for future use in FK checking
m_queryRewriterCache[extent] = queryRewriter;
return queryRewriter;
}
// effects: Returns a context corresponding to extent (if one does not exist, creates one)
private ViewgenContext CreateViewgenContext(EntitySetBase extent, ViewTarget viewTarget, CqlIdentifiers identifiers)
{
QueryRewriter queryRewriter;
if (!m_queryRewriterCache.TryGetValue(extent, out queryRewriter))
{
// collect the cells that belong to this extent (just a few of them since we segment the mapping first)
var cellsForExtent = m_cellGroup.Where(c => c.GetLeftQuery(viewTarget).Extent == extent);
return new ViewgenContext(viewTarget, extent, cellsForExtent, identifiers, m_config, m_queryDomainMap, m_updateDomainMap, m_entityContainerMapping);
}
else
{
return queryRewriter.ViewgenContext;
}
}
private QueryRewriter GenerateViewsForExtentAndType(EdmType generatedType, ViewgenContext context, CqlIdentifiers identifiers, ViewSet views, ViewGenerationMode mode)
{
Debug.Assert(mode != ViewGenerationMode.GenerateAllViews, "By definition this method can not handle generating views for all extents");
QueryRewriter queryRewriter = new QueryRewriter(generatedType, context, mode);
queryRewriter.GenerateViewComponents();
// Get the basic view
CellTreeNode basicView = queryRewriter.BasicView;
if (m_config.IsNormalTracing)
{
Helpers.StringTrace("Basic View: ");
Helpers.StringTraceLine(basicView.ToString());
}
CellTreeNode simplifiedView = GenerateSimplifiedView(basicView, queryRewriter.UsedCells);
if (m_config.IsNormalTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTrace("Simplified View: ");
Helpers.StringTraceLine(simplifiedView.ToString());
}
CqlGenerator cqlGen = new CqlGenerator(simplifiedView, queryRewriter.CaseStatements, identifiers,
context.MemberMaps.ProjectedSlotMap,
queryRewriter.UsedCells.Count, queryRewriter.TopLevelWhereClause);
string viewString = cqlGen.GenerateCql();
GeneratedView generatedView = new GeneratedView(context.Extent, generatedType,
viewString, m_entityContainerMapping.StorageMappingItemCollection, m_config);
views.Add(context.Extent, generatedView);
return queryRewriter;
}
private CellTreeNode GenerateSimplifiedView(CellTreeNode basicView, List usedCells)
{
Debug.Assert(false == basicView.IsEmptyRightFragmentQuery, "Basic view is empty?");
// create 'joined' variables, one for each cell
// We know (say) that out of the 10 cells that we were given, only 7 (say) were
// needed to construct the view for this extent.
int numBoolVars = usedCells.Count;
// We need the boolean expressions in Simplify. Precisely ont boolean expression is set to
// true in each cell query
for (int i = 0; i < numBoolVars; i++)
{
// In the ith cell, set its boolean to be true (i.e., ith boolean)
usedCells[i].RightCellQuery.InitializeBoolExpressions(numBoolVars, i);
}
CellTreeNode simplifiedView = CellTreeSimplifier.MergeNodes(basicView);
return simplifiedView;
}
private void CheckForeignKeyConstraints(ErrorLog errorLog)
{
foreach (ForeignConstraint constraint in m_foreignKeyConstraints)
{
QueryRewriter childRewriter = null;
QueryRewriter parentRewriter = null;
m_queryRewriterCache.TryGetValue(constraint.ChildTable, out childRewriter);
m_queryRewriterCache.TryGetValue(constraint.ParentTable, out parentRewriter);
constraint.CheckConstraint(m_cellGroup, childRewriter, parentRewriter, errorLog, m_config);
}
}
// effects: Given all the cells for a container, groups the cells by
// the left query's extent and returns a dictionary for it
private static KeyToListMap GroupCellsByExtent(IEnumerable cells, ViewTarget viewTarget)
{
// Partition cells by extent -- extent is the top node in
// the tree. Even for compositions for now? CHANGE_[....]_FEATURE_COMPOSITION
KeyToListMap extentCellMap =
new KeyToListMap(EqualityComparer.Default);
foreach (Cell cell in cells)
{
// Get the cell query and determine its extent
CellQuery cellQuery = cell.GetLeftQuery(viewTarget);
extentCellMap.Add(cellQuery.Extent, cell);
}
return extentCellMap;
}
#endregion
#region String Methods
internal override void ToCompactString(StringBuilder builder)
{
Cell.CellsToBuilder(builder, m_cellGroup);
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Data.Common.Utils;
using System.Data.Common.Utils.Boolean;
using System.Data.Mapping.ViewGeneration.Structures;
using System.Data.Mapping.ViewGeneration.Validation;
using System.Data.Mapping.ViewGeneration.QueryRewriting;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Data.Mapping.ViewGeneration.Utils;
using System.Data.Metadata.Edm;
using System.Linq;
namespace System.Data.Mapping.ViewGeneration
{
using ViewSet = KeyToListMap;
using CellGroup = Set;
using WrapperBoolExpr = BoolExpr;
using WrapperTrueExpr = TrueExpr;
using WrapperFalseExpr = FalseExpr;
using WrapperNotExpr = NotExpr;
using WrapperOrExpr = OrExpr;
// This class is responsible for generating query or update mapping
// views from the initial cells.
internal class ViewGenerator : InternalBase
{
#region Fields
private CellGroup m_cellGroup; // The initial cells from which we produce views
private ConfigViewGenerator m_config; // Configuration variables
private MemberDomainMap m_queryDomainMap;
private MemberDomainMap m_updateDomainMap;
private Dictionary m_queryRewriterCache;
private List m_foreignKeyConstraints;
private StorageEntityContainerMapping m_entityContainerMapping;
#endregion
#region Internal API - Only Gatekeeper calls it
// effects: Creates a ViewGenerator object that is capable of
// producing query or update mapping views given the relevant schema
// given the "cells"
internal ViewGenerator(CellGroup cellGroup, ConfigViewGenerator config,
List foreignKeyConstraints,
StorageEntityContainerMapping entityContainerMapping)
{
m_cellGroup = cellGroup;
m_config = config;
m_queryRewriterCache = new Dictionary();
m_foreignKeyConstraints = foreignKeyConstraints;
m_entityContainerMapping = entityContainerMapping;
Dictionary> inheritanceGraph = MetadataHelper.BuildUndirectedGraphOfTypes(entityContainerMapping.StorageMappingItemCollection.EdmItemCollection);
SetConfiguration(entityContainerMapping);
// We fix all the cells at this point
m_queryDomainMap = new MemberDomainMap(ViewTarget.QueryView, m_config.IsValidationEnabled, cellGroup, entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, m_config, inheritanceGraph);
m_updateDomainMap = new MemberDomainMap(ViewTarget.UpdateView, m_config.IsValidationEnabled, cellGroup, entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, m_config, inheritanceGraph);
// We now go and fix the queryDomain map so that it has all the
// values from the S-side as well -- this is needed for domain
// constraint propagation, i.e., values from the S-side get
// propagated to te oneOfConst on the C-side. So we better get
// the "possiblveValues" stuff to contain those constants as well
MemberDomainMap.PropagateUpdateDomainToQueryDomain(cellGroup, m_queryDomainMap, m_updateDomainMap);
UpdateWhereClauseForEachCell(cellGroup, m_queryDomainMap, m_updateDomainMap, m_config);
// We need to simplify cell queries, yet we don't want the conditions to disappear
// So, add an extra value to the domain, temporarily
MemberDomainMap queryOpenDomain = m_queryDomainMap.GetOpenDomain();
MemberDomainMap updateOpenDomain = m_updateDomainMap.GetOpenDomain();
// Make sure the WHERE clauses of the cells reflect the changes
foreach (Cell cell in cellGroup)
{
cell.CQuery.WhereClause.FixDomainMap(queryOpenDomain);
cell.SQuery.WhereClause.FixDomainMap(updateOpenDomain);
cell.CQuery.WhereClause.ExpensiveSimplify();
cell.SQuery.WhereClause.ExpensiveSimplify();
cell.CQuery.WhereClause.FixDomainMap(m_queryDomainMap);
cell.SQuery.WhereClause.FixDomainMap(m_updateDomainMap);
}
}
private void SetConfiguration(StorageEntityContainerMapping entityContainerMapping)
{
m_config.IsValidationEnabled = entityContainerMapping.Validate;
m_config.GenerateUpdateViews = entityContainerMapping.GenerateUpdateViews;
}
// effects: Generates views for the particular cellgroup in this. Returns an
// error log describing the errors that were encountered (if none
// were encountered, the ErrorLog.Count is 0). Places the generated
// views in result
internal ErrorLog GenerateAllBidirectionalViews(ViewSet views, CqlIdentifiers identifiers)
{
// Allow missing attributes for now to make entity splitting run through
// we cannot do this for query views in general: need to obtain the exact enumerated domain
if (m_config.IsNormalTracing)
{
StringBuilder builder = new StringBuilder();
Cell.CellsToBuilder(builder, m_cellGroup);
Helpers.StringTraceLine(builder.ToString());
}
m_config.SetTimeForFinishedActivity(PerfType.CellCreation);
// Check if the cellgroup is consistent and all known S constraints are
// satisified by the known C constraints
CellGroupValidator validator = new CellGroupValidator(m_cellGroup, m_config);
ErrorLog errorLog = validator.Validate();
if (errorLog.Count > 0)
{
errorLog.PrintTrace();
return errorLog;
}
m_config.SetTimeForFinishedActivity(PerfType.KeyConstraint);
// We generate update views first since they perform the main
// validation checks
if (m_config.GenerateUpdateViews)
{
errorLog = GenerateDirectionalViews(ViewTarget.UpdateView, identifiers, views);
if (errorLog.Count > 0)
{
return errorLog; // If we have discovered errors here, do not generate query views
}
}
// Make sure that the foreign key constraints are not violated
if (m_config.IsValidationEnabled)
{
CheckForeignKeyConstraints(errorLog);
}
m_config.SetTimeForFinishedActivity(PerfType.ForeignConstraint);
if (errorLog.Count > 0)
{
errorLog.PrintTrace();
return errorLog; // If we have discovered errors here, do not generate query views
}
// Query views - do not allow missing attributes
// For the S-side, we add NOT ... for each scalar constant so
// that if we have C, P in the mapping but the store has C, P, S,
// we can handle it in the query views
m_updateDomainMap.ExpandDomainsToIncludeAllPossibleValues();
errorLog = GenerateDirectionalViews(ViewTarget.QueryView, identifiers, views);
return errorLog;
}
internal ErrorLog GenerateQueryViewForSingleExtent(ViewSet views, CqlIdentifiers identifiers, EntitySetBase entity, EntityTypeBase type, ViewGenerationMode mode)
{
Debug.Assert(mode != ViewGenerationMode.GenerateAllViews);
if (m_config.IsNormalTracing)
{
StringBuilder builder = new StringBuilder();
Cell.CellsToBuilder(builder, m_cellGroup);
Helpers.StringTraceLine(builder.ToString());
}
// Check if the cellgroup is consistent and all known S constraints are
// satisified by the known C constraints
CellGroupValidator validator = new CellGroupValidator(m_cellGroup, m_config);
ErrorLog errorLog = validator.Validate();
if (errorLog.Count > 0)
{
errorLog.PrintTrace();
return errorLog;
}
// Make sure that the foreign key constraints are not violated
if (m_config.IsValidationEnabled)
{
CheckForeignKeyConstraints(errorLog);
}
if (errorLog.Count > 0)
{
errorLog.PrintTrace();
return errorLog; // If we have discovered errors here, do not generate query views
}
// For the S-side, we add NOT ... for each scalar constant so
// that if we have C, P in the mapping but the store has C, P, S,
// we can handle it in the query views
m_updateDomainMap.ExpandDomainsToIncludeAllPossibleValues();
foreach (Cell cell in m_cellGroup)
{
cell.SQuery.WhereClause.FixDomainMap(m_updateDomainMap);
}
errorLog = GenerateQueryViewForExtentAndType(m_entityContainerMapping, identifiers, views, entity, type, mode);
return errorLog;
}
#endregion
#region Private Methods
// effects: Given the extent cells and a map for the domains of all
// variables in it, fixes the cell constant domains of the where
// clauses in the left queries of cells (left is defined using viewTarget)
private static void UpdateWhereClauseForEachCell(IEnumerable extentCells, MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap, ConfigViewGenerator config)
{
foreach (Cell cell in extentCells)
{
cell.CQuery.UpdateWhereClause(queryDomainMap);
cell.SQuery.UpdateWhereClause(updateDomainMap);
}
// Fix domains of enumerated and boolean types -- i.e., whose domains are enumerable
queryDomainMap.ReduceDomainOfEnumerableToEnumeratedValues(ViewTarget.QueryView, config);
updateDomainMap.ReduceDomainOfEnumerableToEnumeratedValues(ViewTarget.UpdateView, config);
}
private ErrorLog GenerateQueryViewForExtentAndType(StorageEntityContainerMapping entityContainerMapping, CqlIdentifiers identifiers, ViewSet views, EntitySetBase entity, EntityTypeBase type, ViewGenerationMode mode)
{
Debug.Assert(mode != ViewGenerationMode.GenerateAllViews);
// Keep track of the mapping exceptions that we have generated
ErrorLog errorLog = new ErrorLog();
if (m_config.IsViewTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
Helpers.FormatTraceLine("================= Generating {0} Query View for: {1} ===========================",
(mode == ViewGenerationMode.OfTypeViews) ? "OfType" : "OfTypeOnly",
entity.Name);
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
}
try
{
// (1) view generation (checks that extents are fully mapped)
ViewgenContext context = CreateViewgenContext(entity, ViewTarget.QueryView, identifiers);
QueryRewriter queryRewriter = GenerateViewsForExtentAndType(type, context, identifiers, views, mode);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
errorLog.Merge(exception.ErrorLog);
}
return errorLog;
}
// requires: schema refers to C-side or S-side schema for the cells
// inside this. if schema.IsQueryView is true, the left side of cells refers
// to the C side (and vice-versa for the right side)
// effects: Generates the relevant views for the schema side and
// returns them. If allowMissingAttributes is true and attributes
// are missing on the schema side, substitutes them with NULL
// Modifies views to contain the generated views for different
// extents specified by cells and the the schemaContext
private ErrorLog GenerateDirectionalViews(ViewTarget viewTarget, CqlIdentifiers identifiers, ViewSet views)
{
bool isQueryView = viewTarget == ViewTarget.QueryView;
// Create an object that partition cells by extent
KeyToListMap extentCellMap = GroupCellsByExtent(m_cellGroup, viewTarget);
// Keep track of the mapping exceptions that we have generated
ErrorLog errorLog = new ErrorLog();
// Generate views for each extent
foreach (EntitySetBase extent in extentCellMap.Keys)
{
if (m_config.IsViewTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
Helpers.FormatTraceLine("================= Generating {0} View for: {1} ===========================",
isQueryView ? "Query" : "Update", extent.Name);
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
}
try
{
// (1) view generation (checks that extents are fully mapped)
QueryRewriter queryRewriter = GenerateDirectionalViewsForExtent(viewTarget, extent, identifiers, views);
// (2) validation for update views
if (viewTarget == ViewTarget.UpdateView &&
m_config.IsValidationEnabled)
{
if (m_config.IsViewTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
Helpers.FormatTraceLine("----------------- Validation for generated update view for: {0} -----------------",
extent.Name);
Helpers.StringTraceLine(String.Empty);
Helpers.StringTraceLine(String.Empty);
}
RewritingValidator validator = new RewritingValidator(queryRewriter.ViewgenContext, queryRewriter.BasicView);
validator.Validate();
}
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0,
"Incorrectly created mapping exception");
errorLog.Merge(exception.ErrorLog);
}
}
return errorLog;
}
// effects: Generates a view for an extent "extent" that belongs to
// schema "schema". extentCells are the cells for this extent.
// Adds the view corrsponding to the extent to "views"
private QueryRewriter GenerateDirectionalViewsForExtent(ViewTarget viewTarget, EntitySetBase extent, CqlIdentifiers identifiers, ViewSet views)
{
// First normalize the cells in terms of multiconstants, etc
// and then generate the view for the extent
ViewgenContext context = CreateViewgenContext(extent, viewTarget, identifiers);
QueryRewriter queryRewriter = null;
if (m_config.GenerateViewsForEachType)
{
// generate views for each OFTYPE(Extent, Type) combination
foreach (EdmType type in MetadataHelper.GetTypeAndSubtypesOf(extent.ElementType, m_entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, false /*includeAbstractTypes*/))
{
if (m_config.IsViewTracing && false == type.Equals(extent.ElementType))
{
Helpers.FormatTraceLine("CQL View for {0} and type {1}", extent.Name, type.Name);
}
queryRewriter = GenerateViewsForExtentAndType(type, context, identifiers, views, ViewGenerationMode.OfTypeViews);
}
}
else
{
// generate the view for Extent only
queryRewriter = GenerateViewsForExtentAndType(extent.ElementType, context, identifiers, views, ViewGenerationMode.OfTypeViews);
}
if (viewTarget == ViewTarget.QueryView)
{
m_config.SetTimeForFinishedActivity(PerfType.QueryViews);
}
else
{
m_config.SetTimeForFinishedActivity(PerfType.UpdateViews);
}
// cache this rewriter (and context inside it) for future use in FK checking
m_queryRewriterCache[extent] = queryRewriter;
return queryRewriter;
}
// effects: Returns a context corresponding to extent (if one does not exist, creates one)
private ViewgenContext CreateViewgenContext(EntitySetBase extent, ViewTarget viewTarget, CqlIdentifiers identifiers)
{
QueryRewriter queryRewriter;
if (!m_queryRewriterCache.TryGetValue(extent, out queryRewriter))
{
// collect the cells that belong to this extent (just a few of them since we segment the mapping first)
var cellsForExtent = m_cellGroup.Where(c => c.GetLeftQuery(viewTarget).Extent == extent);
return new ViewgenContext(viewTarget, extent, cellsForExtent, identifiers, m_config, m_queryDomainMap, m_updateDomainMap, m_entityContainerMapping);
}
else
{
return queryRewriter.ViewgenContext;
}
}
private QueryRewriter GenerateViewsForExtentAndType(EdmType generatedType, ViewgenContext context, CqlIdentifiers identifiers, ViewSet views, ViewGenerationMode mode)
{
Debug.Assert(mode != ViewGenerationMode.GenerateAllViews, "By definition this method can not handle generating views for all extents");
QueryRewriter queryRewriter = new QueryRewriter(generatedType, context, mode);
queryRewriter.GenerateViewComponents();
// Get the basic view
CellTreeNode basicView = queryRewriter.BasicView;
if (m_config.IsNormalTracing)
{
Helpers.StringTrace("Basic View: ");
Helpers.StringTraceLine(basicView.ToString());
}
CellTreeNode simplifiedView = GenerateSimplifiedView(basicView, queryRewriter.UsedCells);
if (m_config.IsNormalTracing)
{
Helpers.StringTraceLine(String.Empty);
Helpers.StringTrace("Simplified View: ");
Helpers.StringTraceLine(simplifiedView.ToString());
}
CqlGenerator cqlGen = new CqlGenerator(simplifiedView, queryRewriter.CaseStatements, identifiers,
context.MemberMaps.ProjectedSlotMap,
queryRewriter.UsedCells.Count, queryRewriter.TopLevelWhereClause);
string viewString = cqlGen.GenerateCql();
GeneratedView generatedView = new GeneratedView(context.Extent, generatedType,
viewString, m_entityContainerMapping.StorageMappingItemCollection, m_config);
views.Add(context.Extent, generatedView);
return queryRewriter;
}
private CellTreeNode GenerateSimplifiedView(CellTreeNode basicView, List usedCells)
{
Debug.Assert(false == basicView.IsEmptyRightFragmentQuery, "Basic view is empty?");
// create 'joined' variables, one for each cell
// We know (say) that out of the 10 cells that we were given, only 7 (say) were
// needed to construct the view for this extent.
int numBoolVars = usedCells.Count;
// We need the boolean expressions in Simplify. Precisely ont boolean expression is set to
// true in each cell query
for (int i = 0; i < numBoolVars; i++)
{
// In the ith cell, set its boolean to be true (i.e., ith boolean)
usedCells[i].RightCellQuery.InitializeBoolExpressions(numBoolVars, i);
}
CellTreeNode simplifiedView = CellTreeSimplifier.MergeNodes(basicView);
return simplifiedView;
}
private void CheckForeignKeyConstraints(ErrorLog errorLog)
{
foreach (ForeignConstraint constraint in m_foreignKeyConstraints)
{
QueryRewriter childRewriter = null;
QueryRewriter parentRewriter = null;
m_queryRewriterCache.TryGetValue(constraint.ChildTable, out childRewriter);
m_queryRewriterCache.TryGetValue(constraint.ParentTable, out parentRewriter);
constraint.CheckConstraint(m_cellGroup, childRewriter, parentRewriter, errorLog, m_config);
}
}
// effects: Given all the cells for a container, groups the cells by
// the left query's extent and returns a dictionary for it
private static KeyToListMap GroupCellsByExtent(IEnumerable cells, ViewTarget viewTarget)
{
// Partition cells by extent -- extent is the top node in
// the tree. Even for compositions for now? CHANGE_[....]_FEATURE_COMPOSITION
KeyToListMap extentCellMap =
new KeyToListMap(EqualityComparer.Default);
foreach (Cell cell in cells)
{
// Get the cell query and determine its extent
CellQuery cellQuery = cell.GetLeftQuery(viewTarget);
extentCellMap.Add(cellQuery.Extent, cell);
}
return extentCellMap;
}
#endregion
#region String Methods
internal override void ToCompactString(StringBuilder builder)
{
Cell.CellsToBuilder(builder, m_cellGroup);
}
#endregion
}
}
// 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
- DifferencingCollection.cs
- HttpDebugHandler.cs
- ConfigurationElementCollection.cs
- XhtmlConformanceSection.cs
- XmlIgnoreAttribute.cs
- NonVisualControlAttribute.cs
- CursorInteropHelper.cs
- URLString.cs
- PeerNameRecordCollection.cs
- SByteStorage.cs
- RawTextInputReport.cs
- DiagnosticsConfigurationHandler.cs
- ISSmlParser.cs
- PageThemeParser.cs
- ResXDataNode.cs
- IProvider.cs
- FacetChecker.cs
- CatalogZone.cs
- SafeFileMappingHandle.cs
- AsyncCompletedEventArgs.cs
- HostExecutionContextManager.cs
- DynamicILGenerator.cs
- MenuEventArgs.cs
- TreeNodeMouseHoverEvent.cs
- CommandManager.cs
- GridItem.cs
- TreeNode.cs
- StructuredProperty.cs
- MsdtcWrapper.cs
- CallbackValidatorAttribute.cs
- XmlNamespaceMappingCollection.cs
- LinqDataSourceSelectEventArgs.cs
- XmlDocument.cs
- MemoryMappedFileSecurity.cs
- Unit.cs
- PageOutputQuality.cs
- DataGridViewBand.cs
- ClientSettingsSection.cs
- ClientFormsIdentity.cs
- SignatureGenerator.cs
- AQNBuilder.cs
- Evidence.cs
- RowsCopiedEventArgs.cs
- ScaleTransform.cs
- XmlMtomWriter.cs
- FragmentNavigationEventArgs.cs
- ConditionValidator.cs
- DataGridViewSortCompareEventArgs.cs
- ArraySortHelper.cs
- ImportCatalogPart.cs
- XPathNavigatorReader.cs
- CodeAccessSecurityEngine.cs
- ConfigXmlComment.cs
- ObjRef.cs
- Image.cs
- HScrollBar.cs
- TreeWalker.cs
- InputScopeNameConverter.cs
- ByteStreamMessageEncoder.cs
- DelegatingTypeDescriptionProvider.cs
- ProcessProtocolHandler.cs
- PropertyGridEditorPart.cs
- TileBrush.cs
- Cursor.cs
- PtsHost.cs
- XmlC14NWriter.cs
- ImageAnimator.cs
- TextAdaptor.cs
- WebReferencesBuildProvider.cs
- PolicyUnit.cs
- VariableQuery.cs
- BuildResultCache.cs
- ColorContext.cs
- XmlSchemaCompilationSettings.cs
- BaseProcessor.cs
- MatrixCamera.cs
- UTF8Encoding.cs
- DataGridViewCellStyleConverter.cs
- DynamicResourceExtensionConverter.cs
- MessageDispatch.cs
- WindowsListViewItemStartMenu.cs
- ImageAttributes.cs
- Int64Converter.cs
- hresults.cs
- DataGridViewSelectedCellsAccessibleObject.cs
- BasicBrowserDialog.cs
- Privilege.cs
- indexingfiltermarshaler.cs
- ColumnBinding.cs
- InstanceOwner.cs
- StringTraceRecord.cs
- SmiGettersStream.cs
- PolyQuadraticBezierSegment.cs
- RSAOAEPKeyExchangeDeformatter.cs
- StreamSecurityUpgradeAcceptorAsyncResult.cs
- IndexObject.cs
- SByteConverter.cs
- BamlResourceContent.cs
- RowToParametersTransformer.cs
- SequenceDesigner.xaml.cs