Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / 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
- HashHelper.cs
- Int32CAMarshaler.cs
- ProtocolsConfigurationEntry.cs
- EventRecordWrittenEventArgs.cs
- DigestTraceRecordHelper.cs
- ToolStripDropDown.cs
- OleDbRowUpdatedEvent.cs
- DesignerTransactionCloseEvent.cs
- EnvelopedSignatureTransform.cs
- HashHelper.cs
- WebBrowserProgressChangedEventHandler.cs
- TemplateNameScope.cs
- SystemInformation.cs
- QuotaExceededException.cs
- EditorZoneDesigner.cs
- RecognizerStateChangedEventArgs.cs
- FastEncoderStatics.cs
- SoapRpcMethodAttribute.cs
- ContentAlignmentEditor.cs
- FixedSOMFixedBlock.cs
- Rect.cs
- RoleGroupCollection.cs
- HiddenFieldPageStatePersister.cs
- FormsAuthenticationUser.cs
- ObjectViewQueryResultData.cs
- DifferencingCollection.cs
- EventRoute.cs
- RuleCache.cs
- UnsafeNativeMethods.cs
- HttpHandlersSection.cs
- DtrList.cs
- ArrayTypeMismatchException.cs
- Speller.cs
- ImplicitInputBrush.cs
- LoaderAllocator.cs
- PeerSecurityManager.cs
- SecurityRuntime.cs
- MethodBody.cs
- SuppressMessageAttribute.cs
- HandledEventArgs.cs
- StrokeCollection.cs
- ColorAnimation.cs
- OracleLob.cs
- Style.cs
- XmlSchemaSequence.cs
- Parallel.cs
- BuildProviderCollection.cs
- AppendHelper.cs
- EncryptionUtility.cs
- GridViewColumnCollection.cs
- TabItemAutomationPeer.cs
- DbProviderFactories.cs
- URLIdentityPermission.cs
- MenuScrollingVisibilityConverter.cs
- SortKey.cs
- Debugger.cs
- DataGridViewRowHeaderCell.cs
- Content.cs
- DecoderExceptionFallback.cs
- ContentPlaceHolder.cs
- ADRole.cs
- PrinterResolution.cs
- VirtualPathProvider.cs
- AsyncPostBackTrigger.cs
- MatrixValueSerializer.cs
- HttpCacheVary.cs
- TrustManager.cs
- RawTextInputReport.cs
- Clipboard.cs
- Int16Converter.cs
- XmlReader.cs
- PointUtil.cs
- LineBreakRecord.cs
- TraceHandler.cs
- ConnectionPoolManager.cs
- OutputCacheSettings.cs
- SolidBrush.cs
- SelectionHighlightInfo.cs
- DecimalAnimationUsingKeyFrames.cs
- ProfileSettings.cs
- PersonalizationProviderHelper.cs
- TextRangeBase.cs
- ComponentResourceManager.cs
- UriExt.cs
- XmlSchemaExporter.cs
- CreateBookmarkScope.cs
- ParallelTimeline.cs
- SamlAuthorizationDecisionStatement.cs
- HtmlHistory.cs
- SessionChannels.cs
- XmlDocumentSchema.cs
- PublisherIdentityPermission.cs
- DetailsViewRow.cs
- MonthCalendar.cs
- ControlBindingsCollection.cs
- WindowsButton.cs
- AnchoredBlock.cs
- UrlMappingCollection.cs
- CodeAccessPermission.cs
- BigInt.cs