private void AddElseDefaultToCaseStatement(
MemberPath currentPath,
CaseStatement caseStatement,
List <Constant> domain,
CellTreeNode rightDomainQuery,
Tile <FragmentQuery> unionCaseRewriting)
{
Constant defaultConstant;
bool valueForMemberPath = Domain.TryGetDefaultValueForMemberPath(currentPath, out defaultConstant);
if (valueForMemberPath && domain.Contains(defaultConstant))
{
return;
}
CellTreeNode cellTree = QueryRewriter.TileToCellTree(unionCaseRewriting, this._context);
FragmentQuery query = this._context.RightFragmentQP.Difference(rightDomainQuery.RightFragmentQuery, cellTree.RightFragmentQuery);
if (!this._context.RightFragmentQP.IsSatisfiable(query))
{
return;
}
if (valueForMemberPath)
{
caseStatement.AddWhenThen(BoolExpression.True, (ProjectedSlot) new ConstantProjectedSlot(defaultConstant));
}
else
{
query.Condition.ExpensiveSimplify();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine(Strings.ViewGen_No_Default_Value_For_Configuration((object)currentPath.PathToString(new bool?(false))));
this._errorLog.AddEntry(new ErrorLog.Record(ViewGenErrorCode.NoDefaultValue, stringBuilder.ToString(), (IEnumerable <LeftCellWrapper>) this._context.AllWrappersForExtent, string.Empty));
}
}
internal void AddTrivialCaseStatementsForConditionMembers()
{
for (int index = 0; index < this._context.MemberMaps.ProjectedSlotMap.Count; ++index)
{
MemberPath projectedSlot = this._context.MemberMaps.ProjectedSlotMap[index];
if (!projectedSlot.IsScalarType() && !this._caseStatements.ContainsKey(projectedSlot))
{
Constant constant = (Constant) new TypeConstant(projectedSlot.EdmType);
CaseStatement caseStatement = new CaseStatement(projectedSlot);
caseStatement.AddWhenThen(BoolExpression.True, (ProjectedSlot) new ConstantProjectedSlot(constant));
this._caseStatements[projectedSlot] = caseStatement;
}
}
}
private bool AddRewritingToCaseStatement(
Tile <FragmentQuery> rewriting,
CaseStatement caseStatement,
MemberPath currentPath,
Constant domainValue)
{
BoolExpression boolExpression = BoolExpression.True;
bool flag = this._qp.IsContainedIn((Tile <FragmentQuery>)QueryRewriter.CreateTile(this._domainQuery), rewriting);
if (this._qp.IsDisjointFrom((Tile <FragmentQuery>)QueryRewriter.CreateTile(this._domainQuery), rewriting))
{
return(false);
}
int num = flag ? 1 : 0;
ProjectedSlot projectedSlot = !domainValue.HasNotNull() ? (ProjectedSlot) new ConstantProjectedSlot(domainValue) : (ProjectedSlot) new MemberProjectedSlot(currentPath);
BoolExpression condition = flag ? BoolExpression.True : QueryRewriter.TileToBoolExpr(rewriting);
caseStatement.AddWhenThen(condition, projectedSlot);
return(flag);
}
private List <LeftCellWrapper> RemapFromVariables()
{
List <LeftCellWrapper> leftCellWrapperList = new List <LeftCellWrapper>();
int index = 0;
Dictionary <BoolLiteral, BoolLiteral> remap = new Dictionary <BoolLiteral, BoolLiteral>(BoolLiteral.EqualityIdentifierComparer);
foreach (LeftCellWrapper leftCellWrapper in this._context.AllWrappersForExtent)
{
if (this._usedViews.Contains(leftCellWrapper.FragmentQuery))
{
leftCellWrapperList.Add(leftCellWrapper);
int cellNumber = leftCellWrapper.OnlyInputCell.CellNumber;
if (index != cellNumber)
{
remap[(BoolLiteral) new CellIdBoolean(this._identifiers, cellNumber)] = (BoolLiteral) new CellIdBoolean(this._identifiers, index);
}
++index;
}
}
if (remap.Count > 0)
{
this._topLevelWhereClause = this._topLevelWhereClause.RemapLiterals(remap);
Dictionary <MemberPath, CaseStatement> dictionary = new Dictionary <MemberPath, CaseStatement>();
foreach (KeyValuePair <MemberPath, CaseStatement> caseStatement1 in this._caseStatements)
{
CaseStatement caseStatement2 = new CaseStatement(caseStatement1.Key);
foreach (CaseStatement.WhenThen clause in caseStatement1.Value.Clauses)
{
caseStatement2.AddWhenThen(clause.Condition.RemapLiterals(remap), clause.Value);
}
dictionary[caseStatement1.Key] = caseStatement2;
}
this._caseStatements = dictionary;
}
return(leftCellWrapperList);
}
private void GenerateCaseStatements(
IEnumerable <MemberPath> members,
HashSet <FragmentQuery> outputUsedViews)
{
CellTreeNode rightDomainQuery = (CellTreeNode) new OpCellTreeNode(this._context, CellTreeOpType.Union, (CellTreeNode[])this._context.AllWrappersForExtent.Where <LeftCellWrapper>((Func <LeftCellWrapper, bool>)(w => this._usedViews.Contains(w.FragmentQuery))).Select <LeftCellWrapper, LeafCellTreeNode>((Func <LeftCellWrapper, LeafCellTreeNode>)(wrapper => new LeafCellTreeNode(this._context, wrapper))).ToArray <LeafCellTreeNode>());
foreach (MemberPath member in members)
{
List <Constant> list = this.GetDomain(member).ToList <Constant>();
CaseStatement caseStatement = new CaseStatement(member);
Tile <FragmentQuery> tile = (Tile <FragmentQuery>)null;
bool flag = list.Count != 2 || !list.Contains <Constant>(Constant.Null, Constant.EqualityComparer) || !list.Contains <Constant>(Constant.NotNull, Constant.EqualityComparer);
foreach (Constant domainValue in list)
{
if (domainValue == Constant.Undefined && this._context.ViewTarget == ViewTarget.QueryView)
{
caseStatement.AddWhenThen(BoolExpression.False, (ProjectedSlot) new ConstantProjectedSlot(Constant.Undefined));
}
else
{
FragmentQuery memberConditionQuery = this.CreateMemberConditionQuery(member, domainValue);
Tile <FragmentQuery> rewriting;
if (this.FindRewritingAndUsedViews((IEnumerable <MemberPath>)memberConditionQuery.Attributes, memberConditionQuery.Condition, outputUsedViews, out rewriting))
{
if (this._context.ViewTarget == ViewTarget.UpdateView)
{
tile = tile != null?this._qp.Union(tile, rewriting) : rewriting;
}
if (flag)
{
if (this.AddRewritingToCaseStatement(rewriting, caseStatement, member, domainValue))
{
break;
}
}
}
else if (!QueryRewriter.IsDefaultValue(domainValue, member) && !ErrorPatternMatcher.FindMappingErrors(this._context, this._domainMap, this._errorLog))
{
StringBuilder builder = new StringBuilder();
string str1 = StringUtil.FormatInvariant("{0}", (object)this._extentPath);
string str2 = this._context.ViewTarget == ViewTarget.QueryView ? Strings.ViewGen_Entities : Strings.ViewGen_Tuples;
if (this._context.ViewTarget == ViewTarget.QueryView)
{
builder.AppendLine(Strings.Viewgen_CannotGenerateQueryViewUnderNoValidation((object)str1));
}
else
{
builder.AppendLine(Strings.ViewGen_Cannot_Disambiguate_MultiConstant((object)str2, (object)str1));
}
RewritingValidator.EntityConfigurationToUserString(memberConditionQuery.Condition, builder, this._context.ViewTarget == ViewTarget.UpdateView);
this._errorLog.AddEntry(new ErrorLog.Record(ViewGenErrorCode.AmbiguousMultiConstants, builder.ToString(), (IEnumerable <LeftCellWrapper>) this._context.AllWrappersForExtent, string.Empty));
}
}
}
if (this._errorLog.Count == 0)
{
if (this._context.ViewTarget == ViewTarget.UpdateView && flag)
{
this.AddElseDefaultToCaseStatement(member, caseStatement, list, rightDomainQuery, tile);
}
if (caseStatement.Clauses.Count > 0)
{
this._caseStatements[member] = caseStatement;
}
}
}
}
