Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / ndp / fx / src / DataEntity / System / Data / Map / ViewGeneration / CellNormalizer.cs / 2 / CellNormalizer.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.Collections.Generic;
using System.Text;
using System.Data.Mapping.ViewGeneration.Validation;
using System.Data.Mapping.ViewGeneration.QueryRewriting;
using System.Diagnostics;
using System.Collections.ObjectModel;
using System.Data.Mapping.ViewGeneration.Utils;
using System.Data.Metadata.Edm;
using System.Linq;
namespace System.Data.Mapping.ViewGeneration {
using AttributeSet = Set;
using System.Data.Entity;
// This class is responsible for normalizing the cells for an extent so
// that view generation can occur on the normalized cells.
// Main task: Converts an extent cells to normalized form with
// multiconstants along the needed signatures
// Output: A collection of LeftCellWrappers for the extent. Each wrapper has
// the attriutes, the "right" query, and a set of multiconstants X - these
// multiconstants denote a where clause "variable in X".
internal class CellNormalizer : InternalBase {
#region Constructors
// effects: Given an extent and the cells
// for that extent, creates a CellNormalizer object that is capable
// of returning the normalized cells and the extent signatures when needed
internal CellNormalizer(EntitySetBase extent, IEnumerable extentCells, SchemaContext schemaContext,
CqlIdentifiers identifiers,
ConfigViewGenerator config, MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap, StorageEntityContainerMapping entityContainerMapping,
MetadataWorkspace workspace) {
m_extent = extent;
m_schemaContext = schemaContext;
m_config = config;
m_workspace = workspace;
m_entityContainerMapping = entityContainerMapping;
m_identifiers = identifiers;
// Check that the cells that we start out with are ok
ValidateCells(extent, extentCells, schemaContext.ViewTarget);
// create a copy of updateDomainMap so generation of query views later on is not affected
// it is modified in QueryRewriter.AdjustMemberDomainsForUpdateViews
updateDomainMap = updateDomainMap.MakeCopy();
// Create a signature generator that handles all the
// multiconstant work and generating the signatures
MemberDomainMap domainMap = schemaContext.ViewTarget == ViewTarget.QueryView ? queryDomainMap : updateDomainMap;
SignatureGenerator signatureGenerator = new SignatureGenerator(extent, m_workspace);
m_memberMaps = new MemberMaps(schemaContext, signatureGenerator.ProjectedSlotMap,
queryDomainMap, updateDomainMap);
// Create left fragment KB: includes constraints for the extent to be constructed
FragmentQueryKB leftKB = new FragmentQueryKB();
leftKB.CreateVariableConstraints(extent, domainMap, workspace);
m_leftFragmentQP = new FragmentQueryProcessor(leftKB);
m_rewritingCache = new Dictionary>(
FragmentQuery.GetEqualityComparer(m_leftFragmentQP));
// Now using the signatures, create new cells such that
// "extent's" query (C or S) is described in terms of multiconstants
if(!CreateLeftCellWrappers(extentCells, schemaContext.ViewTarget))
{
return;
}
// Create right fragment KB: includes constraints for all extents and association roles of right queries
FragmentQueryKB rightKB = new FragmentQueryKB();
MemberDomainMap rightDomainMap = schemaContext.ViewTarget == ViewTarget.QueryView ? updateDomainMap : queryDomainMap;
foreach (LeftCellWrapper leftCellWrapper in m_cellWrappers)
{
EntitySetBase rightExtent = leftCellWrapper.RightExtent;
rightKB.CreateVariableConstraints(rightExtent, rightDomainMap, workspace);
rightKB.CreateAssociationConstraints(rightExtent, rightDomainMap, workspace);
}
m_rightFragmentQP = new FragmentQueryProcessor(rightKB);
// Check for concurrency control tokens
if (m_schemaContext.ViewTarget == ViewTarget.QueryView)
{
CheckConcurrencyControlTokens();
}
// For backward compatibility -
// order wrappers by increasing domain size, decreasing number of attributes
m_cellWrappers.Sort(LeftCellWrapper.Comparer);
}
#endregion
#region Fields
// Configuration variables
private ConfigViewGenerator m_config;
// Extent for which the cells are being normalized
private EntitySetBase m_extent;
private SchemaContext m_schemaContext;
// Different maps for members
private MemberMaps m_memberMaps;
private MetadataWorkspace m_workspace;
// The normalized cells that are created
private List m_cellWrappers;
// Implicit constraints between members in queries based on schema. E.g., p.Addr IS NOT NULL <=> p IS OF Customer
private FragmentQueryProcessor m_leftFragmentQP;
// In addition to constraints for each right extent contains constraints due to associations
private FragmentQueryProcessor m_rightFragmentQP;
private CqlIdentifiers m_identifiers;
// Maps (left) queries to their rewritings in terms of views
private Dictionary> m_rewritingCache;
private StorageEntityContainerMapping m_entityContainerMapping;
#endregion
#region Properties
internal MemberMaps MemberMaps {
get {
return m_memberMaps;
}
}
// effects: Returns the extent for which the cells have been normalized
internal EntitySetBase Extent {
get { return m_extent; }
}
internal SchemaContext SchemaContext
{
get { return m_schemaContext; }
}
internal ConfigViewGenerator Config
{
get { return m_config; }
}
internal CqlIdentifiers CqlIdentifiers
{
get { return m_identifiers; }
}
internal MetadataWorkspace Workspace
{
get { return m_workspace; }
}
internal FragmentQueryProcessor LeftFragmentQP
{
get { return m_leftFragmentQP; }
}
internal FragmentQueryProcessor RightFragmentQP
{
get { return m_rightFragmentQP; }
}
// effects: Returns all wrappers that were originally relevant for
// this extent
internal List AllWrappersForExtent {
get {
return m_cellWrappers;
}
}
internal StorageEntityContainerMapping EntityContainerMapping
{
get { return m_entityContainerMapping; }
}
#endregion
#region Methods
// effects: Returns the cached rewriting of (left) queries in terms of views, if any
internal bool TryGetCachedRewriting(FragmentQuery query, out Tile rewriting)
{
return m_rewritingCache.TryGetValue(query, out rewriting);
}
// effects: Records the cached rewriting of (left) queries in terms of views
internal void SetCachedRewriting(FragmentQuery query, Tile rewriting)
{
m_rewritingCache[query] = rewriting;
}
// requires: This method be called for query views only
// effects: Checks if the concurrency control tokens are mapped for
// each multiconstant
private void CheckConcurrencyControlTokens() {
// Get the token fields for this extent
EntityTypeBase extentType = m_extent.ElementType;
Set tokenMembers = MetadataHelper.GetConcurrencyMembersForTypeHierarchy(extentType, m_workspace);
Set tokenPaths = new Set(MemberPath.EqualityComparer);
foreach (EdmMember tokenMember in tokenMembers) {
if (tokenMember.DeclaringType.Equals(extentType) == false) {
string message = System.Data.Entity.Strings.ViewGen_Concurrency_Derived_Class_2(tokenMember.Name,
tokenMember.DeclaringType.Name, m_extent);
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.ConcurrencyDerivedClass, message, m_cellWrappers, String.Empty);
ExceptionHelpers.ThrowMappingException(record, m_config);
}
tokenPaths.Add(new MemberPath(m_extent, tokenMember, m_schemaContext.MetadataWorkspace));
}
if (tokenMembers.Count > 0)
{
foreach (LeftCellWrapper wrapper in m_cellWrappers)
{
Set conditionMembers = new Set(
wrapper.OnlyInputCell.CQuery.WhereClause.OneOfConstVariables.Select(oneOf => oneOf.Slot.MemberPath),
MemberPath.EqualityComparer);
conditionMembers.Intersect(tokenPaths);
if (conditionMembers.Count > 0)
{
// There is a condition on concurrency tokens. Throw an exception.
StringBuilder builder = new StringBuilder();
builder.AppendLine(Strings.ViewGen_Concurrency_Invalid_Condition_1(
MemberPath.PropertiesToUserString(conditionMembers, false), m_extent.Name));
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.ConcurrencyTokenHasCondition, builder.ToString(), new LeftCellWrapper[] { wrapper }, String.Empty);
ExceptionHelpers.ThrowMappingException(record, m_config);
}
}
}
}
// effects: Given an extent and its cells, verifies different
// constraints on each cell, e.g., each cell contains mappings for
// the keys (isQueryView indicates if the extent is a C side or S
// side extent). Throws the relevant exception if the validation fails
// If there is a user-visible error (i.e., the user made a mistake,
// throws the real exception for the user)
private static void ValidateCells(EntitySetBase extent, IEnumerable extentCells, ViewTarget viewTarget) {
// Validate the cells for the presence of keys
foreach (Cell cell in extentCells) {
cell.CheckRepInvariant();
CellQuery cellQuery = cell.GetLeftQuery(viewTarget);
// Determine the extent we are recovering
EntitySetBase cellExtent = cellQuery.Extent;
ExceptionHelpers.CheckAndThrowResArgs(extent.Equals(cellExtent), Strings.ViewGen_InputCells_NotIsolated_1,
extent.ElementType.Name, cellExtent.ElementType.Name);
}
}
// effects: Given the cells for the extent (extentCells) along with
// the signatures (multiconstants + needed attributes) for this extent, generates
// the left cell wrappers for it extent (viewTarget indicates whether
// the view is for querying or update purposes
// Modifies m_cellWrappers to contain this list
private bool CreateLeftCellWrappers(IEnumerable extentCells,
ViewTarget viewTarget) {
List extentCellsList = new List(extentCells);
List alignedCells = AlignFields(extentCellsList, m_memberMaps.ProjectedSlotMap, viewTarget);
Debug.Assert(alignedCells.Count == extentCellsList.Count, "Cell counts disagree");
// Go through all the cells and create cell wrappers that can be used for generating the view
m_cellWrappers = new List();
for (int i = 0; i < alignedCells.Count; i++) {
Cell alignedCell = alignedCells[i];
CellQuery left = alignedCell.GetLeftQuery(viewTarget);
CellQuery right = alignedCell.GetRightQuery(viewTarget);
// Obtain the non-null projected slots into attributes
AttributeSet attributes = left.GetNonNullSlots();
BoolExpression fromVariable = BoolExpression.CreateLiteral(new CellIdBoolean(m_identifiers, extentCellsList[i].CellNumber), m_memberMaps.LeftDomainMap);
FragmentQuery fragmentQuery = FragmentQuery.Create(fromVariable, left);
if (viewTarget == ViewTarget.UpdateView)
{
fragmentQuery = m_leftFragmentQP.CreateDerivedViewBySelectingConstantAttributes(fragmentQuery) ?? fragmentQuery;
}
LeftCellWrapper leftWrapper = new LeftCellWrapper(m_schemaContext, attributes, fragmentQuery, right, m_memberMaps,
extentCellsList[i]);
m_cellWrappers.Add(leftWrapper);
}
return true;
}
// effects: Align the fields of each cell in mapping using projectedSlotMap that has a mapping
// for each member of this extent to the slot number of that member in the projected slots
// example:
// input: Proj[A,B,"5"] = Proj[F,"7",G]
// Proj[C,B] = Proj[H,I]
// output: m_projectedSlotMap: A -> 0, B -> 1, C -> 2
// Proj[A,B,null] = Proj[F,"7",null]
// Proj[null,B,C] = Proj[null,I,H]
private static List AlignFields(IEnumerable cells, MemberPathMapBase projectedSlotMap,
ViewTarget viewTarget) {
List outputCells = new List();
// Determine the aligned field for each cell
// The new cells have ProjectedSlotMap.Count number of fields
foreach (Cell cell in cells) {
// If isQueryView is true, we need to consider the C side of
// the cells; otherwise, we look at the S side. Note that we
// CANNOT use cell.LeftQuery since that is determined by
// cell's isQueryView
// The query for which we are constructing the extent
CellQuery mainQuery = cell.GetLeftQuery(viewTarget);
CellQuery otherQuery = cell.GetRightQuery(viewTarget);
CellQuery newMainQuery;
CellQuery newOtherQuery;
// Create both queries where the projected slot map is used
// to determine the order of the fields of the mainquery (of
// course, the otherQuery's fields are aligned automatically)
mainQuery.CreateFieldAlignedCellQueries(otherQuery, projectedSlotMap,
out newMainQuery, out newOtherQuery);
Cell outputCell = viewTarget == ViewTarget.QueryView ?
Cell.CreateCS(newMainQuery, newOtherQuery, cell.CellLabel, cell.CellNumber) :
Cell.CreateCS(newOtherQuery, newMainQuery, cell.CellLabel, cell.CellNumber);
outputCells.Add(outputCell);
}
return outputCells;
}
internal bool IsEmpty(CellTreeNode n)
{
return n.IsEmptyRightFragmentQuery;
}
#endregion
#region String Methods
internal override void ToCompactString(StringBuilder builder) {
LeftCellWrapper.WrappersToStringBuilder(builder, m_cellWrappers, "Left Celll Wrappers");
}
#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.Collections.Generic;
using System.Text;
using System.Data.Mapping.ViewGeneration.Validation;
using System.Data.Mapping.ViewGeneration.QueryRewriting;
using System.Diagnostics;
using System.Collections.ObjectModel;
using System.Data.Mapping.ViewGeneration.Utils;
using System.Data.Metadata.Edm;
using System.Linq;
namespace System.Data.Mapping.ViewGeneration {
using AttributeSet = Set;
using System.Data.Entity;
// This class is responsible for normalizing the cells for an extent so
// that view generation can occur on the normalized cells.
// Main task: Converts an extent cells to normalized form with
// multiconstants along the needed signatures
// Output: A collection of LeftCellWrappers for the extent. Each wrapper has
// the attriutes, the "right" query, and a set of multiconstants X - these
// multiconstants denote a where clause "variable in X".
internal class CellNormalizer : InternalBase {
#region Constructors
// effects: Given an extent and the cells
// for that extent, creates a CellNormalizer object that is capable
// of returning the normalized cells and the extent signatures when needed
internal CellNormalizer(EntitySetBase extent, IEnumerable extentCells, SchemaContext schemaContext,
CqlIdentifiers identifiers,
ConfigViewGenerator config, MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap, StorageEntityContainerMapping entityContainerMapping,
MetadataWorkspace workspace) {
m_extent = extent;
m_schemaContext = schemaContext;
m_config = config;
m_workspace = workspace;
m_entityContainerMapping = entityContainerMapping;
m_identifiers = identifiers;
// Check that the cells that we start out with are ok
ValidateCells(extent, extentCells, schemaContext.ViewTarget);
// create a copy of updateDomainMap so generation of query views later on is not affected
// it is modified in QueryRewriter.AdjustMemberDomainsForUpdateViews
updateDomainMap = updateDomainMap.MakeCopy();
// Create a signature generator that handles all the
// multiconstant work and generating the signatures
MemberDomainMap domainMap = schemaContext.ViewTarget == ViewTarget.QueryView ? queryDomainMap : updateDomainMap;
SignatureGenerator signatureGenerator = new SignatureGenerator(extent, m_workspace);
m_memberMaps = new MemberMaps(schemaContext, signatureGenerator.ProjectedSlotMap,
queryDomainMap, updateDomainMap);
// Create left fragment KB: includes constraints for the extent to be constructed
FragmentQueryKB leftKB = new FragmentQueryKB();
leftKB.CreateVariableConstraints(extent, domainMap, workspace);
m_leftFragmentQP = new FragmentQueryProcessor(leftKB);
m_rewritingCache = new Dictionary>(
FragmentQuery.GetEqualityComparer(m_leftFragmentQP));
// Now using the signatures, create new cells such that
// "extent's" query (C or S) is described in terms of multiconstants
if(!CreateLeftCellWrappers(extentCells, schemaContext.ViewTarget))
{
return;
}
// Create right fragment KB: includes constraints for all extents and association roles of right queries
FragmentQueryKB rightKB = new FragmentQueryKB();
MemberDomainMap rightDomainMap = schemaContext.ViewTarget == ViewTarget.QueryView ? updateDomainMap : queryDomainMap;
foreach (LeftCellWrapper leftCellWrapper in m_cellWrappers)
{
EntitySetBase rightExtent = leftCellWrapper.RightExtent;
rightKB.CreateVariableConstraints(rightExtent, rightDomainMap, workspace);
rightKB.CreateAssociationConstraints(rightExtent, rightDomainMap, workspace);
}
m_rightFragmentQP = new FragmentQueryProcessor(rightKB);
// Check for concurrency control tokens
if (m_schemaContext.ViewTarget == ViewTarget.QueryView)
{
CheckConcurrencyControlTokens();
}
// For backward compatibility -
// order wrappers by increasing domain size, decreasing number of attributes
m_cellWrappers.Sort(LeftCellWrapper.Comparer);
}
#endregion
#region Fields
// Configuration variables
private ConfigViewGenerator m_config;
// Extent for which the cells are being normalized
private EntitySetBase m_extent;
private SchemaContext m_schemaContext;
// Different maps for members
private MemberMaps m_memberMaps;
private MetadataWorkspace m_workspace;
// The normalized cells that are created
private List m_cellWrappers;
// Implicit constraints between members in queries based on schema. E.g., p.Addr IS NOT NULL <=> p IS OF Customer
private FragmentQueryProcessor m_leftFragmentQP;
// In addition to constraints for each right extent contains constraints due to associations
private FragmentQueryProcessor m_rightFragmentQP;
private CqlIdentifiers m_identifiers;
// Maps (left) queries to their rewritings in terms of views
private Dictionary> m_rewritingCache;
private StorageEntityContainerMapping m_entityContainerMapping;
#endregion
#region Properties
internal MemberMaps MemberMaps {
get {
return m_memberMaps;
}
}
// effects: Returns the extent for which the cells have been normalized
internal EntitySetBase Extent {
get { return m_extent; }
}
internal SchemaContext SchemaContext
{
get { return m_schemaContext; }
}
internal ConfigViewGenerator Config
{
get { return m_config; }
}
internal CqlIdentifiers CqlIdentifiers
{
get { return m_identifiers; }
}
internal MetadataWorkspace Workspace
{
get { return m_workspace; }
}
internal FragmentQueryProcessor LeftFragmentQP
{
get { return m_leftFragmentQP; }
}
internal FragmentQueryProcessor RightFragmentQP
{
get { return m_rightFragmentQP; }
}
// effects: Returns all wrappers that were originally relevant for
// this extent
internal List AllWrappersForExtent {
get {
return m_cellWrappers;
}
}
internal StorageEntityContainerMapping EntityContainerMapping
{
get { return m_entityContainerMapping; }
}
#endregion
#region Methods
// effects: Returns the cached rewriting of (left) queries in terms of views, if any
internal bool TryGetCachedRewriting(FragmentQuery query, out Tile rewriting)
{
return m_rewritingCache.TryGetValue(query, out rewriting);
}
// effects: Records the cached rewriting of (left) queries in terms of views
internal void SetCachedRewriting(FragmentQuery query, Tile rewriting)
{
m_rewritingCache[query] = rewriting;
}
// requires: This method be called for query views only
// effects: Checks if the concurrency control tokens are mapped for
// each multiconstant
private void CheckConcurrencyControlTokens() {
// Get the token fields for this extent
EntityTypeBase extentType = m_extent.ElementType;
Set tokenMembers = MetadataHelper.GetConcurrencyMembersForTypeHierarchy(extentType, m_workspace);
Set tokenPaths = new Set(MemberPath.EqualityComparer);
foreach (EdmMember tokenMember in tokenMembers) {
if (tokenMember.DeclaringType.Equals(extentType) == false) {
string message = System.Data.Entity.Strings.ViewGen_Concurrency_Derived_Class_2(tokenMember.Name,
tokenMember.DeclaringType.Name, m_extent);
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.ConcurrencyDerivedClass, message, m_cellWrappers, String.Empty);
ExceptionHelpers.ThrowMappingException(record, m_config);
}
tokenPaths.Add(new MemberPath(m_extent, tokenMember, m_schemaContext.MetadataWorkspace));
}
if (tokenMembers.Count > 0)
{
foreach (LeftCellWrapper wrapper in m_cellWrappers)
{
Set conditionMembers = new Set(
wrapper.OnlyInputCell.CQuery.WhereClause.OneOfConstVariables.Select(oneOf => oneOf.Slot.MemberPath),
MemberPath.EqualityComparer);
conditionMembers.Intersect(tokenPaths);
if (conditionMembers.Count > 0)
{
// There is a condition on concurrency tokens. Throw an exception.
StringBuilder builder = new StringBuilder();
builder.AppendLine(Strings.ViewGen_Concurrency_Invalid_Condition_1(
MemberPath.PropertiesToUserString(conditionMembers, false), m_extent.Name));
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.ConcurrencyTokenHasCondition, builder.ToString(), new LeftCellWrapper[] { wrapper }, String.Empty);
ExceptionHelpers.ThrowMappingException(record, m_config);
}
}
}
}
// effects: Given an extent and its cells, verifies different
// constraints on each cell, e.g., each cell contains mappings for
// the keys (isQueryView indicates if the extent is a C side or S
// side extent). Throws the relevant exception if the validation fails
// If there is a user-visible error (i.e., the user made a mistake,
// throws the real exception for the user)
private static void ValidateCells(EntitySetBase extent, IEnumerable extentCells, ViewTarget viewTarget) {
// Validate the cells for the presence of keys
foreach (Cell cell in extentCells) {
cell.CheckRepInvariant();
CellQuery cellQuery = cell.GetLeftQuery(viewTarget);
// Determine the extent we are recovering
EntitySetBase cellExtent = cellQuery.Extent;
ExceptionHelpers.CheckAndThrowResArgs(extent.Equals(cellExtent), Strings.ViewGen_InputCells_NotIsolated_1,
extent.ElementType.Name, cellExtent.ElementType.Name);
}
}
// effects: Given the cells for the extent (extentCells) along with
// the signatures (multiconstants + needed attributes) for this extent, generates
// the left cell wrappers for it extent (viewTarget indicates whether
// the view is for querying or update purposes
// Modifies m_cellWrappers to contain this list
private bool CreateLeftCellWrappers(IEnumerable extentCells,
ViewTarget viewTarget) {
List extentCellsList = new List(extentCells);
List alignedCells = AlignFields(extentCellsList, m_memberMaps.ProjectedSlotMap, viewTarget);
Debug.Assert(alignedCells.Count == extentCellsList.Count, "Cell counts disagree");
// Go through all the cells and create cell wrappers that can be used for generating the view
m_cellWrappers = new List();
for (int i = 0; i < alignedCells.Count; i++) {
Cell alignedCell = alignedCells[i];
CellQuery left = alignedCell.GetLeftQuery(viewTarget);
CellQuery right = alignedCell.GetRightQuery(viewTarget);
// Obtain the non-null projected slots into attributes
AttributeSet attributes = left.GetNonNullSlots();
BoolExpression fromVariable = BoolExpression.CreateLiteral(new CellIdBoolean(m_identifiers, extentCellsList[i].CellNumber), m_memberMaps.LeftDomainMap);
FragmentQuery fragmentQuery = FragmentQuery.Create(fromVariable, left);
if (viewTarget == ViewTarget.UpdateView)
{
fragmentQuery = m_leftFragmentQP.CreateDerivedViewBySelectingConstantAttributes(fragmentQuery) ?? fragmentQuery;
}
LeftCellWrapper leftWrapper = new LeftCellWrapper(m_schemaContext, attributes, fragmentQuery, right, m_memberMaps,
extentCellsList[i]);
m_cellWrappers.Add(leftWrapper);
}
return true;
}
// effects: Align the fields of each cell in mapping using projectedSlotMap that has a mapping
// for each member of this extent to the slot number of that member in the projected slots
// example:
// input: Proj[A,B,"5"] = Proj[F,"7",G]
// Proj[C,B] = Proj[H,I]
// output: m_projectedSlotMap: A -> 0, B -> 1, C -> 2
// Proj[A,B,null] = Proj[F,"7",null]
// Proj[null,B,C] = Proj[null,I,H]
private static List AlignFields(IEnumerable cells, MemberPathMapBase projectedSlotMap,
ViewTarget viewTarget) {
List outputCells = new List| ();
// Determine the aligned field for each cell
// The new cells have ProjectedSlotMap.Count number of fields
foreach (Cell cell in cells) {
// If isQueryView is true, we need to consider the C side of
// the cells; otherwise, we look at the S side. Note that we
// CANNOT use cell.LeftQuery since that is determined by
// cell's isQueryView
// The query for which we are constructing the extent
CellQuery mainQuery = cell.GetLeftQuery(viewTarget);
CellQuery otherQuery = cell.GetRightQuery(viewTarget);
CellQuery newMainQuery;
CellQuery newOtherQuery;
// Create both queries where the projected slot map is used
// to determine the order of the fields of the mainquery (of
// course, the otherQuery's fields are aligned automatically)
mainQuery.CreateFieldAlignedCellQueries(otherQuery, projectedSlotMap,
out newMainQuery, out newOtherQuery);
Cell outputCell = viewTarget == ViewTarget.QueryView ?
Cell.CreateCS(newMainQuery, newOtherQuery, cell.CellLabel, cell.CellNumber) :
Cell.CreateCS(newOtherQuery, newMainQuery, cell.CellLabel, cell.CellNumber);
outputCells.Add(outputCell);
}
return outputCells;
}
internal bool IsEmpty(CellTreeNode n)
{
return n.IsEmptyRightFragmentQuery;
}
#endregion
#region String Methods
internal override void ToCompactString(StringBuilder builder) {
LeftCellWrapper.WrappersToStringBuilder(builder, m_cellWrappers, "Left Celll Wrappers");
}
#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
- FontStretch.cs
- Image.cs
- Thread.cs
- CellTreeNodeVisitors.cs
- DataGridViewCellEventArgs.cs
- HandlerWithFactory.cs
- HandleCollector.cs
- ResXFileRef.cs
- RelationshipNavigation.cs
- TrimSurroundingWhitespaceAttribute.cs
- ValueTable.cs
- ContextQuery.cs
- CodeArrayCreateExpression.cs
- LicenseException.cs
- RootAction.cs
- DataKeyArray.cs
- TabControlEvent.cs
- ManagementObjectCollection.cs
- SmiEventSink_DeferedProcessing.cs
- ClickablePoint.cs
- XsltConvert.cs
- RootNamespaceAttribute.cs
- SqlTypesSchemaImporter.cs
- PropertyMap.cs
- UserInitiatedRoutedEventPermissionAttribute.cs
- PreservationFileWriter.cs
- WindowsFormsSynchronizationContext.cs
- MemberDomainMap.cs
- ReadOnlyDictionary.cs
- CompilerState.cs
- DefaultAssemblyResolver.cs
- AssociationEndMember.cs
- Input.cs
- DiscardableAttribute.cs
- DataGridTemplateColumn.cs
- _TLSstream.cs
- KoreanCalendar.cs
- ListBase.cs
- OptimalTextSource.cs
- SystemIPInterfaceProperties.cs
- DataGridViewCellPaintingEventArgs.cs
- UrlAuthFailedErrorFormatter.cs
- ZipIOCentralDirectoryBlock.cs
- ObjectSecurity.cs
- StringArrayConverter.cs
- PresentationAppDomainManager.cs
- WebPartDeleteVerb.cs
- DockPanel.cs
- Helper.cs
- Model3D.cs
- DiffuseMaterial.cs
- RowSpanVector.cs
- TraceLevelHelper.cs
- SynchronizationScope.cs
- ContainerControl.cs
- PropertyItem.cs
- TogglePatternIdentifiers.cs
- AsynchronousChannelMergeEnumerator.cs
- ValidatedMobileControlConverter.cs
- DropShadowBitmapEffect.cs
- WebConvert.cs
- SQLSingleStorage.cs
- TdsParser.cs
- BitmapEncoder.cs
- StartUpEventArgs.cs
- XmlCDATASection.cs
- X500Name.cs
- TreeViewCancelEvent.cs
- RemotingClientProxy.cs
- ListViewInsertEventArgs.cs
- OdbcCommandBuilder.cs
- SplineQuaternionKeyFrame.cs
- APCustomTypeDescriptor.cs
- ValueQuery.cs
- TemplatePropertyEntry.cs
- TextChangedEventArgs.cs
- ModifiableIteratorCollection.cs
- Wizard.cs
- MouseGestureValueSerializer.cs
- PieceNameHelper.cs
- SyndicationDeserializer.cs
- RequestQueryProcessor.cs
- SharedPersonalizationStateInfo.cs
- DependentList.cs
- CultureMapper.cs
- _SslState.cs
- WebPartUserCapability.cs
- GridItem.cs
- DnsPermission.cs
- RijndaelManagedTransform.cs
- DataRow.cs
- SiteMapPath.cs
- ScopelessEnumAttribute.cs
- XmlSchemaAttribute.cs
- LinqDataSource.cs
- SystemColorTracker.cs
- RepeatInfo.cs
- BitmapFrame.cs
- ResourceCategoryAttribute.cs
- RequestNavigateEventArgs.cs