internal void UpdateWhereClause(MemberDomainMap domainMap)
{
List <BoolExpression> boolExpressionList = new List <BoolExpression>();
foreach (BoolExpression atom in this.WhereClause.Atoms)
{
MemberRestriction asLiteral = atom.AsLiteral as MemberRestriction;
IEnumerable <Constant> domain = domainMap.GetDomain(asLiteral.RestrictedMemberSlot.MemberPath);
MemberRestriction memberRestriction = asLiteral.CreateCompleteMemberRestriction(domain);
ScalarRestriction scalarRestriction = asLiteral as ScalarRestriction;
bool flag = scalarRestriction != null && !scalarRestriction.Domain.Contains(Constant.Null) && !scalarRestriction.Domain.Contains(Constant.NotNull) && !scalarRestriction.Domain.Contains(Constant.Undefined);
if (flag)
{
domainMap.AddSentinel(memberRestriction.RestrictedMemberSlot.MemberPath);
}
boolExpressionList.Add(BoolExpression.CreateLiteral((BoolLiteral)memberRestriction, domainMap));
if (flag)
{
domainMap.RemoveSentinel(memberRestriction.RestrictedMemberSlot.MemberPath);
}
}
if (boolExpressionList.Count <= 0)
{
return;
}
this.m_whereClause = BoolExpression.CreateAnd(boolExpressionList.ToArray());
}
// requires: caseForOuterJoins corresponds the slot "slotNum"
// effects: Adds a WhenThen corresponding to child to caseForOuterJoins.
private void AddCaseForOuterJoins(CaseStatement caseForOuterJoins, CqlBlock child, int slotNum, CqlIdentifiers identifiers)
{
// Determine the cells that the slot comes from
// and make an OR expression, e.g., WHEN _from0 or _from2 or ... THEN child[slotNum]
var childSlot = child.SlotValue(slotNum);
var constantSlot = childSlot as ConstantProjectedSlot;
if (constantSlot != null &&
constantSlot.CellConstant.IsNull())
{
// NULL being generated by a child - don't need to project
return;
}
var originBool = BoolExpression.False;
for (var i = 0; i < NumBoolSlots; i++)
{
var boolSlotNum = BoolIndexToSlot(i);
if (child.IsProjected(boolSlotNum))
{
// OR it to the expression
var boolExpr = new QualifiedCellIdBoolean(child, identifiers, i);
originBool = BoolExpression.CreateOr(originBool, BoolExpression.CreateLiteral(boolExpr, RightDomainMap));
}
}
// Qualify the slotNum with the child.CqlAlias for the THEN
var slot = child.QualifySlotWithBlockAlias(slotNum);
caseForOuterJoins.AddWhenThen(originBool, slot);
}
private void AddCaseForOuterJoins(
CaseStatement caseForOuterJoins,
CqlBlock child,
int slotNum,
CqlIdentifiers identifiers)
{
ConstantProjectedSlot constantProjectedSlot = child.SlotValue(slotNum) as ConstantProjectedSlot;
if (constantProjectedSlot != null && constantProjectedSlot.CellConstant.IsNull())
{
return;
}
BoolExpression or = BoolExpression.False;
for (int index = 0; index < this.NumBoolSlots; ++index)
{
int slot = this.BoolIndexToSlot(index);
if (child.IsProjected(slot))
{
QualifiedCellIdBoolean qualifiedCellIdBoolean = new QualifiedCellIdBoolean(child, identifiers, index);
or = BoolExpression.CreateOr(or, BoolExpression.CreateLiteral((BoolLiteral)qualifiedCellIdBoolean, this.RightDomainMap));
}
}
QualifiedSlot qualifiedSlot = child.QualifySlotWithBlockAlias(slotNum);
caseForOuterJoins.AddWhenThen(or, (ProjectedSlot)qualifiedSlot);
}
// requires: The CellConstantDomains in the OneOfConsts of the where
// clause are partially done
// effects: Given the domains of different variables in domainMap,
// fixes the whereClause of this such that all the
// CellConstantDomains in OneOfConsts are complete
internal void UpdateWhereClause(MemberDomainMap domainMap)
{
var atoms = new List <BoolExpression>();
foreach (var atom in WhereClause.Atoms)
{
var literal = atom.AsLiteral;
var restriction = literal as MemberRestriction;
Debug.Assert(restriction != null, "All bool literals must be OneOfConst at this point");
// The oneOfConst needs to be fixed with the new possible values from the domainMap.
var possibleValues = domainMap.GetDomain(restriction.RestrictedMemberSlot.MemberPath);
var newOneOf = restriction.CreateCompleteMemberRestriction(possibleValues);
// Prevent optimization of single constraint e.g: "300 in (300)"
// But we want to optimize type constants e.g: "category in (Category)"
// To prevent optimization of bool expressions we add a Sentinel OneOF
var scalarConst = restriction as ScalarRestriction;
var addSentinel =
scalarConst != null &&
!scalarConst.Domain.Contains(Constant.Null) &&
!scalarConst.Domain.Contains(Constant.NotNull) &&
!scalarConst.Domain.Contains(Constant.Undefined);
if (addSentinel)
{
domainMap.AddSentinel(newOneOf.RestrictedMemberSlot.MemberPath);
}
atoms.Add(BoolExpression.CreateLiteral(newOneOf, domainMap));
if (addSentinel)
{
domainMap.RemoveSentinel(newOneOf.RestrictedMemberSlot.MemberPath);
}
}
// We create a new whereClause that has the memberDomainMap set
if (atoms.Count > 0)
{
m_whereClause = BoolExpression.CreateAnd(atoms.ToArray());
}
}