// 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 <Cell> AlignFields(
IEnumerable <Cell> cells, MemberProjectionIndex projectedSlotMap,
ViewTarget viewTarget)
{
var outputCells = new List <Cell>();
// Determine the aligned field for each cell
// The new cells have ProjectedSlotMap.Count number of fields
foreach (var 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
var mainQuery = cell.GetLeftQuery(viewTarget);
var 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);
var 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);
}
private static bool IsMemberPartOfNotNullCondition(
IEnumerable <LeftCellWrapper> wrappers,
MemberPath leftMember,
ViewTarget viewTarget)
{
foreach (LeftCellWrapper wrapper in wrappers)
{
CellQuery leftQuery = wrapper.OnlyInputCell.GetLeftQuery(viewTarget);
if (ErrorPatternMatcher.HasNotNullCondition(leftQuery, leftMember))
{
return(true);
}
CellQuery rightQuery = wrapper.OnlyInputCell.GetRightQuery(viewTarget);
int slotNum = leftQuery.GetProjectedMembers().TakeWhile <MemberPath>((Func <MemberPath, bool>)(path => !path.Equals(leftMember))).Count <MemberPath>();
if (slotNum < leftQuery.GetProjectedMembers().Count <MemberPath>())
{
MemberPath memberPath = ((MemberProjectedSlot)rightQuery.ProjectedSlotAt(slotNum)).MemberPath;
if (ErrorPatternMatcher.HasNotNullCondition(rightQuery, memberPath))
{
return(true);
}
}
}
return(false);
}
protected override void OnResume()
{
base.OnResume();
if (prefs.GetBoolean("FirstRun", true))
{
var vt_btnTutor = new ViewTarget(Resource.Id.btnTutor, this);
ShowcaseView.ConfigOptions config = new ShowcaseView.ConfigOptions();
config.IsOneShot = false;
config.ShowcaseId = 0;
ShowcaseView showcaseView_btnTutor = ShowcaseView.InsertShowcaseView(vt_btnTutor, this,
"Tutorial", "Use this section to train by playing a series of notes.", config);
var vt_btnTuner = new ViewTarget(Resource.Id.btnTuner, this);
config.ShowcaseId = 1;
ShowcaseView showcaseView_btnTuner = ShowcaseView.InsertShowcaseView(vt_btnTuner, this,
"Tuner", "Use this to tune your guitar.", config);
/*NoneOnShowcaseEventListener nosel = new NoneOnShowcaseEventListener();
* nosel.OnShowcaseViewDidHide(showcaseView_btnTuner);
* showcaseView_btnTutor.SetOnShowcaseEventListener(nosel);*/
showcaseView_btnTutor.Show();
prefs.Edit().PutBoolean("FirstRun", false).Commit();
}
}
internal LeftCellWrapper(
ViewTarget viewTarget, Set <MemberPath> attrs,
FragmentQuery fragmentQuery,
CellQuery leftCellQuery, CellQuery rightCellQuery, MemberMaps memberMaps, Cell inputCell)
: this(viewTarget, attrs, fragmentQuery, leftCellQuery, rightCellQuery, memberMaps, Enumerable.Repeat(inputCell, 1))
{
}
// effects: Shrinks the domain of members whose types can be enumerated - currently it applies
// only to boolean type as for enums we don't restrict enum values to specified members only.
// For example NOT(False, True, Null) for a boolean domain should be removed
internal void ReduceEnumerableDomainToEnumeratedValues(ViewTarget target, ConfigViewGenerator config)
{
// Go through the two maps
ReduceEnumerableDomainToEnumeratedValues(target, m_conditionDomainMap, config, m_edmItemCollection);
ReduceEnumerableDomainToEnumeratedValues(target, m_nonConditionDomainMap, config, m_edmItemCollection);
}
private static bool IsMemberPartOfNotNullCondition(
IEnumerable <LeftCellWrapper> wrappers, MemberPath leftMember, ViewTarget viewTarget)
{
foreach (var leftCellWrapper in wrappers)
{
var leftCellQuery = leftCellWrapper.OnlyInputCell.GetLeftQuery(viewTarget);
if (HasNotNullCondition(leftCellQuery, leftMember))
{
return(true);
}
//Now figure out corresponding right side MemberPath
var rightCellQuery = leftCellWrapper.OnlyInputCell.GetRightQuery(viewTarget);
var indexOfMemberInProjection = leftCellQuery.GetProjectedMembers().TakeWhile(path => !path.Equals(leftMember)).Count();
//Member with condition is projected, so check opposite CellQuery's condition
if (indexOfMemberInProjection < leftCellQuery.GetProjectedMembers().Count())
{
var rightmember = ((MemberProjectedSlot)rightCellQuery.ProjectedSlotAt(indexOfMemberInProjection)).MemberPath;
if (HasNotNullCondition(rightCellQuery, rightmember))
{
return(true);
}
}
}
return(false);
}
// 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(IList <Cell> extentCells, ViewTarget viewTarget)
{
var alignedCells = AlignFields(extentCells, m_memberMaps.ProjectedSlotMap, viewTarget);
Debug.Assert(alignedCells.Count == extentCells.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 <LeftCellWrapper>();
for (var i = 0; i < alignedCells.Count; i++)
{
var alignedCell = alignedCells[i];
var left = alignedCell.GetLeftQuery(viewTarget);
var right = alignedCell.GetRightQuery(viewTarget);
// Obtain the non-null projected slots into attributes
var attributes = left.GetNonNullSlots();
var fromVariable = BoolExpression.CreateLiteral(
new CellIdBoolean(m_identifiers, extentCells[i].CellNumber), m_memberMaps.LeftDomainMap);
var leftFragmentQuery = FragmentQuery.Create(fromVariable, left);
if (viewTarget == ViewTarget.UpdateView)
{
leftFragmentQuery = m_leftFragmentQP.CreateDerivedViewBySelectingConstantAttributes(leftFragmentQuery)
?? leftFragmentQuery;
}
var leftWrapper = new LeftCellWrapper(
m_viewTarget, attributes, leftFragmentQuery, left, right, m_memberMaps,
extentCells[i]);
m_cellWrappers.Add(leftWrapper);
}
return(true);
}
private QueryRewriter GenerateDirectionalViewsForExtent(
ViewTarget viewTarget,
EntitySetBase extent,
CqlIdentifiers identifiers,
KeyToListMap <EntitySetBase, GeneratedView> views)
{
ViewgenContext viewgenContext = this.CreateViewgenContext(extent, viewTarget, identifiers);
QueryRewriter queryRewriter = (QueryRewriter)null;
if (this.m_config.GenerateViewsForEachType)
{
foreach (EdmType generatedType in MetadataHelper.GetTypeAndSubtypesOf((EdmType)extent.ElementType, (ItemCollection)this.m_entityContainerMapping.StorageMappingItemCollection.EdmItemCollection, false))
{
if (this.m_config.IsViewTracing && !generatedType.Equals((object)extent.ElementType))
{
Helpers.FormatTraceLine("CQL View for {0} and type {1}", (object)extent.Name, (object)generatedType.Name);
}
queryRewriter = this.GenerateViewsForExtentAndType(generatedType, viewgenContext, identifiers, views, ViewGenMode.OfTypeViews);
}
}
else
{
queryRewriter = this.GenerateViewsForExtentAndType((EdmType)extent.ElementType, viewgenContext, identifiers, views, ViewGenMode.OfTypeViews);
}
if (viewTarget == ViewTarget.QueryView)
{
this.m_config.SetTimeForFinishedActivity(PerfType.QueryViews);
}
else
{
this.m_config.SetTimeForFinishedActivity(PerfType.UpdateViews);
}
this.m_queryRewriterCache[extent] = queryRewriter;
return(queryRewriter);
}
// 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 schemaContext
private ErrorLog GenerateDirectionalViews(ViewTarget viewTarget, CqlIdentifiers identifiers, ViewSet views)
{
var isQueryView = viewTarget == ViewTarget.QueryView;
// Partition cells by extent.
var extentCellMap = GroupCellsByExtent(m_cellGroup, viewTarget);
// Keep track of the mapping exceptions that we have generated
var errorLog = new ErrorLog();
// Generate views for each extent
foreach (var 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)
var 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);
}
var 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);
}
internal CellQuery GetRightQuery(ViewTarget side)
{
if (side != ViewTarget.QueryView)
{
return(this.m_cQuery);
}
return(this.m_sQuery);
}
private Frame GetTargetFrame(ViewTarget target)
{
_lastTarget = target;
if (target == ViewTarget.MainFrame)
{
return((Frame)Window.Current.Content);
}
return(_subFrame);
}
internal MemberDomainMap(
ViewTarget viewTarget,
bool isValidationEnabled,
IEnumerable <Cell> extentCells,
EdmItemCollection edmItemCollection,
ConfigViewGenerator config,
Dictionary <EntityType, Set <EntityType> > inheritanceGraph)
{
this.m_conditionDomainMap = new Dictionary <MemberPath, Set <Constant> >(MemberPath.EqualityComparer);
this.m_edmItemCollection = edmItemCollection;
Dictionary <MemberPath, Set <Constant> > dictionary = viewTarget != ViewTarget.UpdateView ? Domain.ComputeConstantDomainSetsForSlotsInQueryViews(extentCells, this.m_edmItemCollection, isValidationEnabled) : Domain.ComputeConstantDomainSetsForSlotsInUpdateViews(extentCells, this.m_edmItemCollection);
foreach (Cell extentCell in extentCells)
{
foreach (MemberRestriction memberRestriction in extentCell.GetLeftQuery(viewTarget).GetConjunctsFromWhereClause())
{
MemberPath memberPath = memberRestriction.RestrictedMemberSlot.MemberPath;
Set <Constant> set;
if (!dictionary.TryGetValue(memberPath, out set))
{
set = Domain.DeriveDomainFromMemberPath(memberPath, edmItemCollection, isValidationEnabled);
}
if (set.Contains(Constant.Null) || !memberRestriction.Domain.Values.All <Constant>((Func <Constant, bool>)(conditionConstant => conditionConstant.Equals((object)Constant.NotNull))))
{
if (set.Count <= 0 || !set.Contains(Constant.Null) && memberRestriction.Domain.Values.Contains <Constant>(Constant.Null))
{
ExceptionHelpers.ThrowMappingException(new ErrorLog.Record(ViewGenErrorCode.InvalidCondition, Strings.ViewGen_InvalidCondition((object)memberPath.PathToString(new bool?(false))), extentCell, string.Empty), config);
}
if (!memberPath.IsAlwaysDefined(inheritanceGraph))
{
set.Add(Constant.Undefined);
}
this.AddToDomainMap(memberPath, (IEnumerable <Constant>)set);
}
}
}
this.m_nonConditionDomainMap = new Dictionary <MemberPath, Set <Constant> >(MemberPath.EqualityComparer);
foreach (Cell extentCell in extentCells)
{
foreach (MemberProjectedSlot allQuerySlot in extentCell.GetLeftQuery(viewTarget).GetAllQuerySlots())
{
MemberPath memberPath = allQuerySlot.MemberPath;
if (!this.m_conditionDomainMap.ContainsKey(memberPath) && !this.m_nonConditionDomainMap.ContainsKey(memberPath))
{
Set <Constant> set = Domain.DeriveDomainFromMemberPath(memberPath, this.m_edmItemCollection, true);
if (!memberPath.IsAlwaysDefined(inheritanceGraph))
{
set.Add(Constant.Undefined);
}
Set <Constant> iconstants = Domain.ExpandNegationsInDomain((IEnumerable <Constant>)set, (IEnumerable <Constant>)set);
this.m_nonConditionDomainMap.Add(memberPath, (Set <Constant>) new MemberDomainMap.CellConstantSetInfo(iconstants));
}
}
}
}
// requires: The Where clause satisfies the same requirements a GetConjunctsFromWhereClause
// effects: For each slot that has a NotNull condition in the where
// clause, checks if it is projected. If all such slots are
// projected, returns null. Else returns an error record
internal ErrorLog.Record CheckForProjectedNotNullSlots(Cell sourceCell, IEnumerable <Cell> associationSets)
{
StringBuilder builder = new StringBuilder();
bool foundError = false;
foreach (MemberRestriction restriction in Conditions)
{
if (restriction.Domain.ContainsNotNull())
{
MemberProjectedSlot slot = MemberProjectedSlot.GetSlotForMember(m_projectedSlots, restriction.RestrictedMemberSlot.MemberPath);
if (slot == null) //member with not null condition is not mapped in this extent
{
bool missingMapping = true;
if (Extent is EntitySet)
{
bool isCQuery = sourceCell.CQuery == this;
ViewTarget target = isCQuery ? ViewTarget.QueryView : ViewTarget.UpdateView;
CellQuery rightCellQuery = isCQuery? sourceCell.SQuery : sourceCell.CQuery;
//Find out if there is an association mapping but only if the current Not Null condition is on an EntitySet
EntitySet rightExtent = rightCellQuery.Extent as EntitySet;
if (rightExtent != null)
{
List <AssociationSet> associations = MetadataHelper.GetAssociationsForEntitySet(rightCellQuery.Extent as EntitySet);
foreach (var association in associations.Where(association => association.AssociationSetEnds.Any(end => (end.CorrespondingAssociationEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One &&
(MetadataHelper.GetOppositeEnd(end).EntitySet.EdmEquals(rightExtent))))))
{
foreach (var associationCell in associationSets.Where(c => c.GetRightQuery(target).Extent.EdmEquals(association)))
{
if (MemberProjectedSlot.GetSlotForMember(associationCell.GetLeftQuery(target).ProjectedSlots, restriction.RestrictedMemberSlot.MemberPath) != null)
{
missingMapping = false;
}
}
}
}
}
if (missingMapping)
{
// condition of NotNull and slot not being projected
builder.AppendLine(System.Data.Entity.Strings.ViewGen_NotNull_No_Projected_Slot(
restriction.RestrictedMemberSlot.MemberPath.PathToString(false)));
foundError = true;
}
}
}
}
if (false == foundError)
{
return(null);
}
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.NotNullNoProjectedSlot, builder.ToString(), sourceCell, String.Empty);
return(record);
}
internal MemberMaps(
ViewTarget viewTarget,
MemberProjectionIndex projectedSlotMap,
MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap)
{
this.m_projectedSlotMap = projectedSlotMap;
this.m_queryDomainMap = queryDomainMap;
this.m_updateDomainMap = updateDomainMap;
this.m_viewTarget = viewTarget;
}
internal MemberMaps(ViewTarget viewTarget, MemberProjectionIndex projectedSlotMap,
MemberDomainMap queryDomainMap, MemberDomainMap updateDomainMap)
{
m_projectedSlotMap = projectedSlotMap;
m_queryDomainMap = queryDomainMap;
m_updateDomainMap = updateDomainMap;
Debug.Assert(m_queryDomainMap != null);
Debug.Assert(m_updateDomainMap != null);
Debug.Assert(m_projectedSlotMap != null);
m_viewTarget = viewTarget;
}
internal ViewgenContext(
ViewTarget viewTarget,
EntitySetBase extent,
IList <Cell> extentCells,
CqlIdentifiers identifiers,
ConfigViewGenerator config,
MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap,
EntityContainerMapping entityContainerMapping)
{
foreach (Cell extentCell in (IEnumerable <Cell>)extentCells)
{
;
}
this.m_extent = extent;
this.m_viewTarget = viewTarget;
this.m_config = config;
this.m_edmItemCollection = entityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
this.m_entityContainerMapping = entityContainerMapping;
this.m_identifiers = identifiers;
updateDomainMap = updateDomainMap.MakeCopy();
MemberDomainMap domainMap = viewTarget == ViewTarget.QueryView ? queryDomainMap : updateDomainMap;
this.m_memberMaps = new MemberMaps(viewTarget, MemberProjectionIndex.Create(extent, this.m_edmItemCollection), queryDomainMap, updateDomainMap);
FragmentQueryKBChaseSupport kb1 = new FragmentQueryKBChaseSupport();
kb1.CreateVariableConstraints(extent, domainMap, this.m_edmItemCollection);
this.m_leftFragmentQP = new FragmentQueryProcessor(kb1);
this.m_rewritingCache = new Dictionary <FragmentQuery, Tile <FragmentQuery> >(FragmentQuery.GetEqualityComparer(this.m_leftFragmentQP));
if (!this.CreateLeftCellWrappers(extentCells, viewTarget))
{
return;
}
FragmentQueryKBChaseSupport kb2 = new FragmentQueryKBChaseSupport();
MemberDomainMap memberDomainMap = viewTarget == ViewTarget.QueryView ? updateDomainMap : queryDomainMap;
foreach (LeftCellWrapper cellWrapper in this.m_cellWrappers)
{
EntitySetBase rightExtent = cellWrapper.RightExtent;
kb2.CreateVariableConstraints(rightExtent, memberDomainMap, this.m_edmItemCollection);
kb2.CreateAssociationConstraints(rightExtent, memberDomainMap, this.m_edmItemCollection);
}
if (this.m_viewTarget == ViewTarget.UpdateView)
{
this.CreateConstraintsForForeignKeyAssociationsAffectingThisWrapper((FragmentQueryKB)kb2, memberDomainMap);
}
this.m_rightFragmentQP = new FragmentQueryProcessor(kb2);
if (this.m_viewTarget == ViewTarget.QueryView)
{
this.CheckConcurrencyControlTokens();
}
this.m_cellWrappers.Sort(LeftCellWrapper.Comparer);
}
internal ErrorLog.Record CheckForProjectedNotNullSlots(
Cell sourceCell,
IEnumerable <Cell> associationSets)
{
StringBuilder stringBuilder = new StringBuilder();
bool flag1 = false;
foreach (MemberRestriction condition in this.Conditions)
{
if (condition.Domain.ContainsNotNull() && MemberProjectedSlot.GetSlotForMember((IEnumerable <ProjectedSlot>) this.m_projectedSlots, condition.RestrictedMemberSlot.MemberPath) == null)
{
bool flag2 = true;
if (this.Extent is EntitySet)
{
bool flag3 = sourceCell.CQuery == this;
ViewTarget target = flag3 ? ViewTarget.QueryView : ViewTarget.UpdateView;
CellQuery cellQuery = flag3 ? sourceCell.SQuery : sourceCell.CQuery;
EntitySet rightExtent = cellQuery.Extent as EntitySet;
if (rightExtent != null)
{
foreach (AssociationSet associationSet in MetadataHelper.GetAssociationsForEntitySet((EntitySetBase)(cellQuery.Extent as EntitySet)).Where <AssociationSet>((Func <AssociationSet, bool>)(association => association.AssociationSetEnds.Any <AssociationSetEnd>((Func <AssociationSetEnd, bool>)(end =>
{
if (end.CorrespondingAssociationEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One)
{
return(MetadataHelper.GetOppositeEnd(end).EntitySet.EdmEquals((MetadataItem)rightExtent));
}
return(false);
})))))
{
AssociationSet association = associationSet;
foreach (Cell cell in associationSets.Where <Cell>((Func <Cell, bool>)(c => c.GetRightQuery(target).Extent.EdmEquals((MetadataItem)association))))
{
if (MemberProjectedSlot.GetSlotForMember((IEnumerable <ProjectedSlot>)cell.GetLeftQuery(target).ProjectedSlots, condition.RestrictedMemberSlot.MemberPath) != null)
{
flag2 = false;
}
}
}
}
}
if (flag2)
{
stringBuilder.AppendLine(Strings.ViewGen_NotNull_No_Projected_Slot((object)condition.RestrictedMemberSlot.MemberPath.PathToString(new bool?(false))));
flag1 = true;
}
}
}
if (!flag1)
{
return((ErrorLog.Record)null);
}
return(new ErrorLog.Record(ViewGenErrorCode.NotNullNoProjectedSlot, stringBuilder.ToString(), sourceCell, string.Empty));
}
// effects: Creates a LeftCellWrapper of the form:
// Project[attrs] (Select[var IN {domain}] (Extent)) = cellquery
// memberMaps is the set of maps used for producing the query or update views
internal LeftCellWrapper(ViewTarget viewTarget, Set <MemberPath> attrs,
FragmentQuery fragmentQuery,
CellQuery leftCellQuery, CellQuery rightCellQuery, MemberMaps memberMaps, IEnumerable <Cell> inputCells)
{
m_leftFragmentQuery = fragmentQuery;
m_rightCellQuery = rightCellQuery;
m_leftCellQuery = leftCellQuery;
m_attributes = attrs;
m_viewTarget = viewTarget;
m_memberMaps = memberMaps;
m_mergedCells = new HashSet <Cell>(inputCells);
}
private static KeyToListMap <EntitySetBase, Cell> GroupCellsByExtent(
IEnumerable <Cell> cells,
ViewTarget viewTarget)
{
KeyToListMap <EntitySetBase, Cell> keyToListMap = new KeyToListMap <EntitySetBase, Cell>((IEqualityComparer <EntitySetBase>)EqualityComparer <EntitySetBase> .Default);
foreach (Cell cell in cells)
{
CellQuery leftQuery = cell.GetLeftQuery(viewTarget);
keyToListMap.Add(leftQuery.Extent, cell);
}
return(keyToListMap);
}
internal MemberMaps(ViewTarget viewTarget, MemberProjectionIndex projectedSlotMap,
MemberDomainMap queryDomainMap, MemberDomainMap updateDomainMap)
{
m_projectedSlotMap = projectedSlotMap;
m_queryDomainMap = queryDomainMap;
m_updateDomainMap = updateDomainMap;
Debug.Assert(m_queryDomainMap != null);
Debug.Assert(m_updateDomainMap != null);
Debug.Assert(m_projectedSlotMap != null);
m_viewTarget = viewTarget;
}
private ViewgenContext CreateViewgenContext(
EntitySetBase extent,
ViewTarget viewTarget,
CqlIdentifiers identifiers)
{
QueryRewriter queryRewriter;
if (this.m_queryRewriterCache.TryGetValue(extent, out queryRewriter))
{
return(queryRewriter.ViewgenContext);
}
List <Cell> list = this.m_cellGroup.Where <Cell>((Func <Cell, bool>)(c => c.GetLeftQuery(viewTarget).Extent == extent)).ToList <Cell>();
return(new ViewgenContext(viewTarget, extent, (IList <Cell>)list, identifiers, this.m_config, this.m_queryDomainMap, this.m_updateDomainMap, this.m_entityContainerMapping));
}
// 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 void SearchShipData(ViewTarget target)
{
Cursor = Cursors.Wait;
try
{
_shipDataGridItemsSource.Clear();
using (var entities = new FleetManagerDataEntities())
{
var newList = new ObservableCollection <ShipDataModel>();
switch (target)
{
case ViewTarget.Possession:
foreach (var ship in entities.ViewPossessionShips.OrderBy(s => s.ShipBaseCode + s.Grade.ToString()))
{
var model = Mapper.Map <ViewPossessionShips, ShipDataModel>(ship);
newList.Add(model);
}
break;
case ViewTarget.NotPossession:
foreach (var ship in entities.ViewNotPossessionShips.OrderBy(s => s.ShipBaseCode + s.Grade.ToString()))
{
var model = Mapper.Map <ViewNotPossessionShips, ShipDataModel>(ship);
newList.Add(model);
}
break;
case ViewTarget.All:
foreach (var ship in entities.ViewAllShips.OrderBy(s => s.ShipBaseCode + s.Grade.ToString()))
{
var model = Mapper.Map <ViewAllShips, ShipDataModel>(ship);
newList.Add(model);
}
break;
}
ShipDataGridItemsSource = newList;
}
}
finally
{
Cursor = null;
}
}
private static List <Cell> AlignFields(
IEnumerable <Cell> cells,
MemberProjectionIndex projectedSlotMap,
ViewTarget viewTarget)
{
List <Cell> cellList = new List <Cell>();
foreach (Cell cell1 in cells)
{
CellQuery newMainQuery;
CellQuery newOtherQuery;
cell1.GetLeftQuery(viewTarget).CreateFieldAlignedCellQueries(cell1.GetRightQuery(viewTarget), projectedSlotMap, out newMainQuery, out newOtherQuery);
Cell cell2 = viewTarget == ViewTarget.QueryView ? Cell.CreateCS(newMainQuery, newOtherQuery, cell1.CellLabel, cell1.CellNumber) : Cell.CreateCS(newOtherQuery, newMainQuery, cell1.CellLabel, cell1.CellNumber);
cellList.Add(cell2);
}
return(cellList);
}
private ErrorLog GenerateDirectionalViews(
ViewTarget viewTarget,
CqlIdentifiers identifiers,
KeyToListMap <EntitySetBase, GeneratedView> views)
{
bool flag = viewTarget == ViewTarget.QueryView;
KeyToListMap <EntitySetBase, Cell> keyToListMap = ViewGenerator.GroupCellsByExtent((IEnumerable <Cell>) this.m_cellGroup, viewTarget);
ErrorLog errorLog = new ErrorLog();
foreach (EntitySetBase key in keyToListMap.Keys)
{
if (this.m_config.IsViewTracing)
{
Helpers.StringTraceLine(string.Empty);
Helpers.StringTraceLine(string.Empty);
Helpers.FormatTraceLine("================= Generating {0} View for: {1} ===========================", flag ? (object)"Query" : (object)"Update", (object)key.Name);
Helpers.StringTraceLine(string.Empty);
Helpers.StringTraceLine(string.Empty);
}
try
{
QueryRewriter directionalViewsForExtent = this.GenerateDirectionalViewsForExtent(viewTarget, key, identifiers, views);
if (viewTarget == ViewTarget.UpdateView)
{
if (this.m_config.IsValidationEnabled)
{
if (this.m_config.IsViewTracing)
{
Helpers.StringTraceLine(string.Empty);
Helpers.StringTraceLine(string.Empty);
Helpers.FormatTraceLine("----------------- Validation for generated update view for: {0} -----------------", (object)key.Name);
Helpers.StringTraceLine(string.Empty);
Helpers.StringTraceLine(string.Empty);
}
new RewritingValidator(directionalViewsForExtent.ViewgenContext, directionalViewsForExtent.BasicView).Validate();
}
}
}
catch (InternalMappingException ex)
{
errorLog.Merge(ex.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 corresponding 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
var context = CreateViewgenContext(extent, viewTarget, identifiers);
QueryRewriter queryRewriter = null;
if (m_config.GenerateViewsForEachType)
{
// generate views for each OFTYPE(Extent, Type) combination
foreach (
var 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, ViewGenMode.OfTypeViews);
}
}
else
{
// generate the view for Extent only
queryRewriter = GenerateViewsForExtentAndType(extent.ElementType, context, identifiers, views, ViewGenMode.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);
}
private bool CreateLeftCellWrappers(IList <Cell> extentCells, ViewTarget viewTarget)
{
List <Cell> cellList = ViewgenContext.AlignFields((IEnumerable <Cell>)extentCells, this.m_memberMaps.ProjectedSlotMap, viewTarget);
this.m_cellWrappers = new List <LeftCellWrapper>();
for (int index = 0; index < cellList.Count; ++index)
{
Cell cell = cellList[index];
CellQuery leftQuery = cell.GetLeftQuery(viewTarget);
CellQuery rightQuery = cell.GetRightQuery(viewTarget);
Set <MemberPath> nonNullSlots = leftQuery.GetNonNullSlots();
FragmentQuery fragmentQuery = FragmentQuery.Create(BoolExpression.CreateLiteral((BoolLiteral) new CellIdBoolean(this.m_identifiers, extentCells[index].CellNumber), this.m_memberMaps.LeftDomainMap), leftQuery);
if (viewTarget == ViewTarget.UpdateView)
{
fragmentQuery = this.m_leftFragmentQP.CreateDerivedViewBySelectingConstantAttributes(fragmentQuery) ?? fragmentQuery;
}
this.m_cellWrappers.Add(new LeftCellWrapper(this.m_viewTarget, nonNullSlots, fragmentQuery, leftQuery, rightQuery, this.m_memberMaps, extentCells[index]));
}
return(true);
}
private bool TryCreateAdditionalCellWithCondition(
Cell originalCell,
MemberPath memberToExpand,
bool conditionValue,
ViewTarget viewTarget,
out Cell result)
{
result = (Cell)null;
MemberPath extentMemberPath1 = originalCell.GetLeftQuery(viewTarget).SourceExtentMemberPath;
MemberPath extentMemberPath2 = originalCell.GetRightQuery(viewTarget).SourceExtentMemberPath;
int slotNum1 = originalCell.GetLeftQuery(viewTarget).GetProjectedMembers().TakeWhile <MemberPath>((Func <MemberPath, bool>)(path => !path.Equals(memberToExpand))).Count <MemberPath>();
MemberPath rightSidePath = ((MemberProjectedSlot)originalCell.GetRightQuery(viewTarget).ProjectedSlotAt(slotNum1)).MemberPath;
List <ProjectedSlot> slots1 = new List <ProjectedSlot>();
List <ProjectedSlot> slots2 = new List <ProjectedSlot>();
ScalarConstant negatedCondition = new ScalarConstant((object)!conditionValue);
if (originalCell.GetLeftQuery(viewTarget).Conditions.Where <MemberRestriction>((Func <MemberRestriction, bool>)(restriction => restriction.RestrictedMemberSlot.MemberPath.Equals(memberToExpand))).Where <MemberRestriction>((Func <MemberRestriction, bool>)(restriction => restriction.Domain.Values.Contains <Constant>((Constant)negatedCondition))).Any <MemberRestriction>() || originalCell.GetRightQuery(viewTarget).Conditions.Where <MemberRestriction>((Func <MemberRestriction, bool>)(restriction => restriction.RestrictedMemberSlot.MemberPath.Equals(rightSidePath))).Where <MemberRestriction>((Func <MemberRestriction, bool>)(restriction => restriction.Domain.Values.Contains <Constant>((Constant)negatedCondition))).Any <MemberRestriction>())
{
return(false);
}
for (int slotNum2 = 0; slotNum2 < originalCell.GetLeftQuery(viewTarget).NumProjectedSlots; ++slotNum2)
{
slots1.Add(originalCell.GetLeftQuery(viewTarget).ProjectedSlotAt(slotNum2));
}
for (int slotNum2 = 0; slotNum2 < originalCell.GetRightQuery(viewTarget).NumProjectedSlots; ++slotNum2)
{
slots2.Add(originalCell.GetRightQuery(viewTarget).ProjectedSlotAt(slotNum2));
}
BoolExpression literal1 = BoolExpression.CreateLiteral((BoolLiteral) new ScalarRestriction(memberToExpand, (Constant) new ScalarConstant((object)conditionValue)), (MemberDomainMap)null);
BoolExpression and1 = BoolExpression.CreateAnd(originalCell.GetLeftQuery(viewTarget).WhereClause, literal1);
BoolExpression literal2 = BoolExpression.CreateLiteral((BoolLiteral) new ScalarRestriction(rightSidePath, (Constant) new ScalarConstant((object)conditionValue)), (MemberDomainMap)null);
BoolExpression and2 = BoolExpression.CreateAnd(originalCell.GetRightQuery(viewTarget).WhereClause, literal2);
CellQuery cellQuery1 = new CellQuery(slots2, and2, extentMemberPath2, originalCell.GetRightQuery(viewTarget).SelectDistinctFlag);
CellQuery cellQuery2 = new CellQuery(slots1, and1, extentMemberPath1, originalCell.GetLeftQuery(viewTarget).SelectDistinctFlag);
Cell cell = viewTarget != ViewTarget.UpdateView ? Cell.CreateCS(cellQuery2, cellQuery1, originalCell.CellLabel, this.m_currentCellNumber) : Cell.CreateCS(cellQuery1, cellQuery2, originalCell.CellLabel, this.m_currentCellNumber);
++this.m_currentCellNumber;
result = cell;
return(true);
}
// effects: Fixes the domains of variables in this as specified in FixEnumerableDomains
private static void ReduceEnumerableDomainToEnumeratedValues(ViewTarget target, Dictionary <MemberPath, CellConstantSet> domainMap, ConfigViewGenerator config,
EdmItemCollection edmItemCollection)
{
foreach (MemberPath member in domainMap.Keys)
{
if (MetadataHelper.HasDiscreteDomain(member.EdmType) == false)
{
continue;
}
CellConstantSet domain = Domain.DeriveDomainFromMemberPath(member, edmItemCollection, true /* leaveDomainUnbounded */);
CellConstantSet extra = domainMap[member].Difference(domain);
extra.Remove(Constant.Undefined);
if (extra.Count > 0)
{ // domainMap has extra members -- we should get rid of them
if (config.IsNormalTracing)
{
Helpers.FormatTraceLine("Changed domain of {0} from {1} - subtract {2}", member, domainMap[member], extra);
}
domainMap[member].Subtract(extra);
}
}
}
// 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<EntitySetBase, Cell> GroupCellsByExtent(IEnumerable<Cell> cells, ViewTarget viewTarget)
{
// Partition cells by extent -- extent is the top node in
// the tree. Even for compositions for now? CHANGE_ADYA_FEATURE_COMPOSITION
var extentCellMap =
new KeyToListMap<EntitySetBase, Cell>(EqualityComparer<EntitySetBase>.Default);
foreach (var cell in cells)
{
// Get the cell query and determine its extent
var cellQuery = cell.GetLeftQuery(viewTarget);
extentCellMap.Add(cellQuery.Extent, cell);
}
return extentCellMap;
}
// 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;
}
}
// 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
var context = CreateViewgenContext(extent, viewTarget, identifiers);
QueryRewriter queryRewriter = null;
if (m_config.GenerateViewsForEachType)
{
// generate views for each OFTYPE(Extent, Type) combination
foreach (
var 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, ViewGenMode.OfTypeViews);
}
}
else
{
// generate the view for Extent only
queryRewriter = GenerateViewsForExtentAndType(extent.ElementType, context, identifiers, views, ViewGenMode.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;
}
// 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)
{
var isQueryView = viewTarget == ViewTarget.QueryView;
// Partition cells by extent.
var extentCellMap = GroupCellsByExtent(m_cellGroup, viewTarget);
// Keep track of the mapping exceptions that we have generated
var errorLog = new ErrorLog();
// Generate views for each extent
foreach (var 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)
var 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);
}
var 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: Creates a map with all the condition member constants
// from extentCells. viewtarget determines whether the view is an
// update or query view
internal MemberDomainMap(ViewTarget viewTarget, bool isValidationEnabled, IEnumerable<Cell> extentCells, EdmItemCollection edmItemCollection, ConfigViewGenerator config, Dictionary<EntityType, Set<EntityType>> inheritanceGraph)
{
m_conditionDomainMap = new Dictionary<MemberPath, CellConstantSet>(MemberPath.EqualityComparer);
m_edmItemCollection = edmItemCollection;
Dictionary<MemberPath, CellConstantSet> domainMap = null;
if (viewTarget == ViewTarget.UpdateView)
{
domainMap = Domain.ComputeConstantDomainSetsForSlotsInUpdateViews(extentCells, m_edmItemCollection);
}
else
{
domainMap = Domain.ComputeConstantDomainSetsForSlotsInQueryViews(extentCells, m_edmItemCollection, isValidationEnabled);
}
foreach (Cell cell in extentCells)
{
CellQuery cellQuery = cell.GetLeftQuery(viewTarget);
// Get the atoms from cellQuery and only keep the ones that
// are condition members
foreach (MemberRestriction condition in cellQuery.GetConjunctsFromWhereClause())
{
// Note: TypeConditions are created using OneOfTypeConst and
// scalars are created using OneOfScalarConst
MemberPath memberPath = condition.RestrictedMemberSlot.MemberPath;
Debug.Assert(condition is ScalarRestriction || condition is TypeRestriction,
"Unexpected restriction");
// Take the narrowed domain from domainMap, if any
CellConstantSet domainValues;
if (!domainMap.TryGetValue(memberPath, out domainValues))
{
domainValues = Domain.DeriveDomainFromMemberPath(memberPath, edmItemCollection, isValidationEnabled);
}
//Don't count conditions that are satisfied through IsNull=false
if (!domainValues.Contains(Constant.Null))
{
//multiple values of condition represent disjunction in conditions (not currently supported)
// if there is any condition constant that is NotNull
if (condition.Domain.Values.All(conditionConstant => (conditionConstant.Equals(Constant.NotNull))))
{
continue;
}
//else there is atleast one condition value that is allowed, continue view generation
}
//------------------------------------------
//| Nullable | IsNull | Test case |
//| T | T | T |
//| T | F | T |
//| F | T | F |
//| F | F | T |
//------------------------------------------
//IsNull condition on a member that is non nullable is an invalid condition
if (domainValues.Count <= 0 || (!domainValues.Contains(Constant.Null) && condition.Domain.Values.Contains(Constant.Null)))
{
string message = System.Data.Entity.Strings.ViewGen_InvalidCondition(memberPath.PathToString(false));
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.InvalidCondition, message, cell, String.Empty);
ExceptionHelpers.ThrowMappingException(record, config);
}
if (memberPath.IsAlwaysDefined(inheritanceGraph) == false)
{
domainValues.Add(Constant.Undefined);
}
AddToDomainMap(memberPath, domainValues);
}
}
// Fill up the domains for the remaining slots as well
m_nonConditionDomainMap = new Dictionary<MemberPath, CellConstantSet>(MemberPath.EqualityComparer);
foreach (Cell cell in extentCells)
{
CellQuery cellQuery = cell.GetLeftQuery(viewTarget);
// Get the atoms from cellQuery and only keep the ones that
// are condition members
foreach (MemberProjectedSlot slot in cellQuery.GetAllQuerySlots())
{
MemberPath member = slot.MemberPath;
if (m_conditionDomainMap.ContainsKey(member) == false && m_nonConditionDomainMap.ContainsKey(member) == false)
{
CellConstantSet memberSet = Domain.DeriveDomainFromMemberPath(member, m_edmItemCollection, true /* Regardless of validation, leave the domain unbounded because this is not a condition member */);
if (member.IsAlwaysDefined(inheritanceGraph) == false)
{ // nonConditionMember may belong to subclass
memberSet.Add(Constant.Undefined);
}
memberSet = Domain.ExpandNegationsInDomain(memberSet, memberSet);
m_nonConditionDomainMap.Add(member, new CellConstantSetInfo(memberSet, slot));
}
}
}
}
// effects: Fixes the domains of variables in this as specified in FixEnumerableDomains
private static void ReduceEnumerableDomainToEnumeratedValues(ViewTarget target, Dictionary<MemberPath, CellConstantSet> domainMap, ConfigViewGenerator config,
EdmItemCollection edmItemCollection)
{
foreach (MemberPath member in domainMap.Keys)
{
if (MetadataHelper.HasDiscreteDomain(member.EdmType) == false)
{
continue;
}
CellConstantSet domain = Domain.DeriveDomainFromMemberPath(member, edmItemCollection, true /* leaveDomainUnbounded */);
CellConstantSet extra = domainMap[member].Difference(domain);
extra.Remove(Constant.Undefined);
if (extra.Count > 0)
{ // domainMap has extra members -- we should get rid of them
if (config.IsNormalTracing)
{
Helpers.FormatTraceLine("Changed domain of {0} from {1} - subtract {2}", member, domainMap[member], extra);
}
domainMap[member].Subtract(extra);
}
}
}
// 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<Cell> AlignFields(
IEnumerable<Cell> cells, MemberProjectionIndex projectedSlotMap,
ViewTarget viewTarget)
{
var outputCells = new List<Cell>();
// Determine the aligned field for each cell
// The new cells have ProjectedSlotMap.Count number of fields
foreach (var 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
var mainQuery = cell.GetLeftQuery(viewTarget);
var 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);
var 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 ViewgenContext(
ViewTarget viewTarget, EntitySetBase extent, IList <Cell> extentCells,
CqlIdentifiers identifiers, ConfigViewGenerator config, MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap, StorageEntityContainerMapping entityContainerMapping)
{
foreach (var cell in extentCells)
{
Debug.Assert(extent.Equals(cell.GetLeftQuery(viewTarget).Extent));
Debug.Assert(cell.CQuery.NumProjectedSlots == cell.SQuery.NumProjectedSlots);
}
m_extent = extent;
m_viewTarget = viewTarget;
m_config = config;
m_edmItemCollection = entityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
m_entityContainerMapping = entityContainerMapping;
m_identifiers = identifiers;
// 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
var domainMap = viewTarget == ViewTarget.QueryView ? queryDomainMap : updateDomainMap;
m_memberMaps = new MemberMaps(
viewTarget, MemberProjectionIndex.Create(extent, m_edmItemCollection), queryDomainMap, updateDomainMap);
// Create left fragment KB: includes constraints for the extent to be constructed
var leftKB = new FragmentQueryKBChaseSupport();
leftKB.CreateVariableConstraints(extent, domainMap, m_edmItemCollection);
m_leftFragmentQP = new FragmentQueryProcessor(leftKB);
m_rewritingCache = new Dictionary <FragmentQuery, Tile <FragmentQuery> >(
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, viewTarget))
{
return;
}
// Create right fragment KB: includes constraints for all extents and association roles of right queries
var rightKB = new FragmentQueryKBChaseSupport();
var rightDomainMap = viewTarget == ViewTarget.QueryView ? updateDomainMap : queryDomainMap;
foreach (var leftCellWrapper in m_cellWrappers)
{
var rightExtent = leftCellWrapper.RightExtent;
rightKB.CreateVariableConstraints(rightExtent, rightDomainMap, m_edmItemCollection);
rightKB.CreateAssociationConstraints(rightExtent, rightDomainMap, m_edmItemCollection);
}
if (m_viewTarget == ViewTarget.UpdateView)
{
CreateConstraintsForForeignKeyAssociationsAffectingThisWrapper(rightKB, rightDomainMap);
}
m_rightFragmentQP = new FragmentQueryProcessor(rightKB);
// Check for concurrency control tokens
if (m_viewTarget == ViewTarget.QueryView)
{
CheckConcurrencyControlTokens();
}
// For backward compatibility -
// order wrappers by increasing domain size, decreasing number of attributes
m_cellWrappers.Sort(LeftCellWrapper.Comparer);
}
private void SearchShipData(ViewTarget target)
{
Cursor = Cursors.Wait;
try
{
_shipDataGridItemsSource.Clear();
using (var entities = new FleetManagerDataEntities())
{
var newList = new ObservableCollection<ShipDataModel>();
switch (target)
{
case ViewTarget.Possession:
foreach (var ship in entities.ViewPossessionShips.OrderBy(s => s.ShipBaseCode + s.Grade.ToString()))
{
var model = Mapper.Map<ViewPossessionShips, ShipDataModel>(ship);
newList.Add(model);
}
break;
case ViewTarget.NotPossession:
foreach (var ship in entities.ViewNotPossessionShips.OrderBy(s => s.ShipBaseCode + s.Grade.ToString()))
{
var model = Mapper.Map<ViewNotPossessionShips, ShipDataModel>(ship);
newList.Add(model);
}
break;
case ViewTarget.All:
foreach (var ship in entities.ViewAllShips.OrderBy(s => s.ShipBaseCode + s.Grade.ToString()))
{
var model = Mapper.Map<ViewAllShips, ShipDataModel>(ship);
newList.Add(model);
}
break;
}
ShipDataGridItemsSource = newList;
}
}
finally
{
Cursor = null;
}
}
// effects: Returns the S query for ViewTarget.QueryView and C query for ViewTarget.UpdateView
internal CellQuery GetRightQuery(ViewTarget side)
{
return side == ViewTarget.QueryView ? m_sQuery : m_cQuery;
}
internal ViewgenContext(
ViewTarget viewTarget, EntitySetBase extent, IList<Cell> extentCells,
CqlIdentifiers identifiers, ConfigViewGenerator config, MemberDomainMap queryDomainMap,
MemberDomainMap updateDomainMap, EntityContainerMapping entityContainerMapping)
{
foreach (var cell in extentCells)
{
Debug.Assert(extent.Equals(cell.GetLeftQuery(viewTarget).Extent));
Debug.Assert(cell.CQuery.NumProjectedSlots == cell.SQuery.NumProjectedSlots);
}
m_extent = extent;
m_viewTarget = viewTarget;
m_config = config;
m_edmItemCollection = entityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
m_entityContainerMapping = entityContainerMapping;
m_identifiers = identifiers;
// 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
var domainMap = viewTarget == ViewTarget.QueryView ? queryDomainMap : updateDomainMap;
m_memberMaps = new MemberMaps(
viewTarget, MemberProjectionIndex.Create(extent, m_edmItemCollection), queryDomainMap, updateDomainMap);
// Create left fragment KB: includes constraints for the extent to be constructed
var leftKB = new FragmentQueryKBChaseSupport();
leftKB.CreateVariableConstraints(extent, domainMap, m_edmItemCollection);
m_leftFragmentQP = new FragmentQueryProcessor(leftKB);
m_rewritingCache = new Dictionary<FragmentQuery, Tile<FragmentQuery>>(
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, viewTarget))
{
return;
}
// Create right fragment KB: includes constraints for all extents and association roles of right queries
var rightKB = new FragmentQueryKBChaseSupport();
var rightDomainMap = viewTarget == ViewTarget.QueryView ? updateDomainMap : queryDomainMap;
foreach (var leftCellWrapper in m_cellWrappers)
{
var rightExtent = leftCellWrapper.RightExtent;
rightKB.CreateVariableConstraints(rightExtent, rightDomainMap, m_edmItemCollection);
rightKB.CreateAssociationConstraints(rightExtent, rightDomainMap, m_edmItemCollection);
}
if (m_viewTarget == ViewTarget.UpdateView)
{
CreateConstraintsForForeignKeyAssociationsAffectingThisWrapper(rightKB, rightDomainMap);
}
m_rightFragmentQP = new FragmentQueryProcessor(rightKB);
// Check for concurrency control tokens
if (m_viewTarget == ViewTarget.QueryView)
{
CheckConcurrencyControlTokens();
}
// For backward compatibility -
// order wrappers by increasing domain size, decreasing number of attributes
m_cellWrappers.Sort(LeftCellWrapper.Comparer);
}
// effects: Shrinks the domain of members whose types can be enumerated - currently it applies
// only to boolean type as for enums we don't restrict enum values to specified members only.
// For example NOT(False, True, Null) for a boolean domain should be removed
internal void ReduceEnumerableDomainToEnumeratedValues(ViewTarget target, ConfigViewGenerator config)
{
// Go through the two maps
ReduceEnumerableDomainToEnumeratedValues(target, m_conditionDomainMap, config, m_edmItemCollection);
ReduceEnumerableDomainToEnumeratedValues(target, m_nonConditionDomainMap, config, m_edmItemCollection);
}
// 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(IList<Cell> extentCells, ViewTarget viewTarget)
{
var alignedCells = AlignFields(extentCells, m_memberMaps.ProjectedSlotMap, viewTarget);
Debug.Assert(alignedCells.Count == extentCells.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<LeftCellWrapper>();
for (var i = 0; i < alignedCells.Count; i++)
{
var alignedCell = alignedCells[i];
var left = alignedCell.GetLeftQuery(viewTarget);
var right = alignedCell.GetRightQuery(viewTarget);
// Obtain the non-null projected slots into attributes
var attributes = left.GetNonNullSlots();
var fromVariable = BoolExpression.CreateLiteral(
new CellIdBoolean(m_identifiers, extentCells[i].CellNumber), m_memberMaps.LeftDomainMap);
var leftFragmentQuery = FragmentQuery.Create(fromVariable, left);
if (viewTarget == ViewTarget.UpdateView)
{
leftFragmentQuery = m_leftFragmentQP.CreateDerivedViewBySelectingConstantAttributes(leftFragmentQuery)
?? leftFragmentQuery;
}
var leftWrapper = new LeftCellWrapper(
m_viewTarget, attributes, leftFragmentQuery, left, right, m_memberMaps,
extentCells[i]);
m_cellWrappers.Add(leftWrapper);
}
return true;
}
// <summary>
// Given a cell, a member and a boolean condition on that member, creates additional cell
// which with the specified restriction on the member in addition to original condition.
// e.i conjunction of original condition AND member in newCondition
// Creation fails when the original condition contradicts new boolean condition
// ViewTarget tells whether MemberPath is in Cquery or SQuery
// </summary>
private bool TryCreateAdditionalCellWithCondition(
Cell originalCell, MemberPath memberToExpand, bool conditionValue, ViewTarget viewTarget, out Cell result)
{
DebugCheck.NotNull(originalCell);
DebugCheck.NotNull(memberToExpand);
result = null;
//Create required structures
var leftExtent = originalCell.GetLeftQuery(viewTarget).SourceExtentMemberPath;
var rightExtent = originalCell.GetRightQuery(viewTarget).SourceExtentMemberPath;
//Now for the given left-side projected member, find corresponding right-side member that it is mapped to
var indexOfBooLMemberInProjection =
originalCell.GetLeftQuery(viewTarget).GetProjectedMembers().TakeWhile(path => !path.Equals(memberToExpand)).Count();
var rightConditionMemberSlot =
((MemberProjectedSlot)originalCell.GetRightQuery(viewTarget).ProjectedSlotAt(indexOfBooLMemberInProjection));
var rightSidePath = rightConditionMemberSlot.MemberPath;
var leftSlots = new List <ProjectedSlot>();
var rightSlots = new List <ProjectedSlot>();
//Check for impossible conditions (otherwise we get inaccurate pre-validation errors)
var negatedCondition = new ScalarConstant(!conditionValue);
if (originalCell.GetLeftQuery(viewTarget).Conditions
.Where(restriction => restriction.RestrictedMemberSlot.MemberPath.Equals(memberToExpand))
.Where(restriction => restriction.Domain.Values.Contains(negatedCondition)).Any() ||
originalCell.GetRightQuery(viewTarget).Conditions
.Where(restriction => restriction.RestrictedMemberSlot.MemberPath.Equals(rightSidePath))
.Where(restriction => restriction.Domain.Values.Contains(negatedCondition)).Any())
{
return(false);
}
//End check
//Create Projected Slots
// Map all slots in original cell (not just keys) because some may be required (non nullable and no default)
// and others may have not_null condition so MUST be projected. Rely on the user doing the right thing, otherwise
// they will get the error message anyway
for (var i = 0; i < originalCell.GetLeftQuery(viewTarget).NumProjectedSlots; i++)
{
leftSlots.Add(originalCell.GetLeftQuery(viewTarget).ProjectedSlotAt(i));
}
for (var i = 0; i < originalCell.GetRightQuery(viewTarget).NumProjectedSlots; i++)
{
rightSlots.Add(originalCell.GetRightQuery(viewTarget).ProjectedSlotAt(i));
}
//Create condition boolena expressions
var leftQueryWhereClause =
BoolExpression.CreateLiteral(new ScalarRestriction(memberToExpand, new ScalarConstant(conditionValue)), null);
leftQueryWhereClause = BoolExpression.CreateAnd(originalCell.GetLeftQuery(viewTarget).WhereClause, leftQueryWhereClause);
var rightQueryWhereClause =
BoolExpression.CreateLiteral(new ScalarRestriction(rightSidePath, new ScalarConstant(conditionValue)), null);
rightQueryWhereClause = BoolExpression.CreateAnd(originalCell.GetRightQuery(viewTarget).WhereClause, rightQueryWhereClause);
//Create additional Cells
var rightQuery = new CellQuery(
rightSlots, rightQueryWhereClause, rightExtent, originalCell.GetRightQuery(viewTarget).SelectDistinctFlag);
var leftQuery = new CellQuery(
leftSlots, leftQueryWhereClause, leftExtent, originalCell.GetLeftQuery(viewTarget).SelectDistinctFlag);
Cell newCell;
if (viewTarget == ViewTarget.UpdateView)
{
newCell = Cell.CreateCS(rightQuery, leftQuery, originalCell.CellLabel, m_currentCellNumber);
}
else
{
newCell = Cell.CreateCS(leftQuery, rightQuery, originalCell.CellLabel, m_currentCellNumber);
}
m_currentCellNumber++;
result = newCell;
return(true);
}
/// <summary>
/// Given a cell, a member and a boolean condition on that member, creates additional cell
/// which with the specified restriction on the member in addition to original condition.
/// e.i conjunction of original condition AND member in newCondition
/// Creation fails when the original condition contradicts new boolean condition
/// ViewTarget tells whether MemberPath is in Cquery or SQuery
/// </summary>
private bool TryCreateAdditionalCellWithCondition(
Cell originalCell, MemberPath memberToExpand, bool conditionValue, ViewTarget viewTarget, out Cell result)
{
DebugCheck.NotNull(originalCell);
DebugCheck.NotNull(memberToExpand);
result = null;
//Create required structures
var leftExtent = originalCell.GetLeftQuery(viewTarget).SourceExtentMemberPath;
var rightExtent = originalCell.GetRightQuery(viewTarget).SourceExtentMemberPath;
//Now for the given left-side projected member, find corresponding right-side member that it is mapped to
var indexOfBooLMemberInProjection =
originalCell.GetLeftQuery(viewTarget).GetProjectedMembers().TakeWhile(path => !path.Equals(memberToExpand)).Count();
var rightConditionMemberSlot =
((MemberProjectedSlot)originalCell.GetRightQuery(viewTarget).ProjectedSlotAt(indexOfBooLMemberInProjection));
var rightSidePath = rightConditionMemberSlot.MemberPath;
var leftSlots = new List<ProjectedSlot>();
var rightSlots = new List<ProjectedSlot>();
//Check for impossible conditions (otehrwise we get inaccurate pre-validation errors)
var negatedCondition = new ScalarConstant(!conditionValue);
if (originalCell.GetLeftQuery(viewTarget).Conditions
.Where(restriction => restriction.RestrictedMemberSlot.MemberPath.Equals(memberToExpand))
.Where(restriction => restriction.Domain.Values.Contains(negatedCondition)).Any()
|| originalCell.GetRightQuery(viewTarget).Conditions
.Where(restriction => restriction.RestrictedMemberSlot.MemberPath.Equals(rightSidePath))
.Where(restriction => restriction.Domain.Values.Contains(negatedCondition)).Any())
{
return false;
}
//End check
//Create Projected Slots
// Map all slots in original cell (not just keys) because some may be required (non nullable and no default)
// and others may have not_null condition so MUST be projected. Rely on the user doing the right thing, otherwise
// they will get the error message anyway
for (var i = 0; i < originalCell.GetLeftQuery(viewTarget).NumProjectedSlots; i++)
{
leftSlots.Add(originalCell.GetLeftQuery(viewTarget).ProjectedSlotAt(i));
}
for (var i = 0; i < originalCell.GetRightQuery(viewTarget).NumProjectedSlots; i++)
{
rightSlots.Add(originalCell.GetRightQuery(viewTarget).ProjectedSlotAt(i));
}
//Create condition boolena expressions
var leftQueryWhereClause =
BoolExpression.CreateLiteral(new ScalarRestriction(memberToExpand, new ScalarConstant(conditionValue)), null);
leftQueryWhereClause = BoolExpression.CreateAnd(originalCell.GetLeftQuery(viewTarget).WhereClause, leftQueryWhereClause);
var rightQueryWhereClause =
BoolExpression.CreateLiteral(new ScalarRestriction(rightSidePath, new ScalarConstant(conditionValue)), null);
rightQueryWhereClause = BoolExpression.CreateAnd(originalCell.GetRightQuery(viewTarget).WhereClause, rightQueryWhereClause);
//Create additional Cells
var rightQuery = new CellQuery(
rightSlots, rightQueryWhereClause, rightExtent, originalCell.GetRightQuery(viewTarget).SelectDistinctFlag);
var leftQuery = new CellQuery(
leftSlots, leftQueryWhereClause, leftExtent, originalCell.GetLeftQuery(viewTarget).SelectDistinctFlag);
Cell newCell;
if (viewTarget == ViewTarget.UpdateView)
{
newCell = Cell.CreateCS(rightQuery, leftQuery, originalCell.CellLabel, m_currentCellNumber);
}
else
{
newCell = Cell.CreateCS(leftQuery, rightQuery, originalCell.CellLabel, m_currentCellNumber);
}
m_currentCellNumber++;
result = newCell;
return true;
}
