// The real work happens here in the literal's RemapBool internal override DomainBoolExpr VisitTerm(DomainTermExpr expression) { BoolLiteral literal = BoolExpression.GetBoolLiteral(expression); BoolLiteral newLiteral = literal.RemapBool(m_remap); return(newLiteral.GetDomainBoolExpression(m_memberDomainMap)); }
// The real work happens here in the literal's FixRange internal override DomainBoolExpr VisitTerm(DomainTermExpr expression) { BoolLiteral literal = BoolExpression.GetBoolLiteral(expression); DomainBoolExpr result = literal.FixRange(expression.Identifier.Range, m_memberDomainMap); return(result); }
/// <summary> /// Creates a term expression of the form: "<paramref name="literal"/> in <paramref name="range"/> with all possible values being <paramref name="domain"/>". /// </summary> internal static DomainTermExpr MakeTermExpression(BoolLiteral literal, IEnumerable <Constant> domain, IEnumerable <Constant> range) { Set <Constant> domainSet = new Set <Constant>(domain, Constant.EqualityComparer); Set <Constant> rangeSet = new Set <Constant>(range, Constant.EqualityComparer); return(MakeTermExpression(literal, domainSet, rangeSet)); }
internal override StringBuilder VisitTerm(DomainTermExpr expression) { BoolLiteral literal = BoolExpression.GetBoolLiteral(expression); literal.ToCompactString(m_builder); return(m_builder); }
// The real work happends here - the slots are obtained from the literal internal override DomainBoolExpr VisitTerm(DomainTermExpr expression) { BoolLiteral literal = BoolExpression.GetBoolLiteral(expression); literal.GetRequiredSlots(m_projectedSlotMap, m_requiredSlots); return(expression); }
// Check if the oneOfConst is complete or not internal override bool VisitTerm(DomainTermExpr expression) { BoolLiteral literal = BoolExpression.GetBoolLiteral(expression); MemberRestriction restriction = literal as MemberRestriction; bool result = restriction == null || restriction.IsComplete == true; return(result); }
internal override T_Return VisitTerm(DomainTermExpr expression) { // If m_skipIsNotNull is true at this point, it means that no ancestor of this // node is OR or NOT BoolLiteral literal = BoolExpression.GetBoolLiteral(expression); return(BooleanLiteralAsCql(literal, m_skipIsNotNull)); }
protected override bool IsEqualTo(BoolLiteral right) { CellIdBoolean rightBoolean = right as CellIdBoolean; if (rightBoolean == null) { return(false); } return(m_index == rightBoolean.m_index); }
protected override bool IsEqualTo(BoolLiteral right) { RoleBoolean rightBoolean = right as RoleBoolean; if (rightBoolean == null) { return(false); } return(m_metadataItem == rightBoolean.m_metadataItem); }
/// <summary> /// Creates a term expression of the form: "<paramref name="literal"/> in <paramref name="range"/> with all possible values being <paramref name="domain"/>". /// </summary> internal static DomainTermExpr MakeTermExpression(BoolLiteral literal, Set <Constant> domain, Set <Constant> range) { domain.MakeReadOnly(); range.MakeReadOnly(); DomainVariable variable = new DomainVariable(literal, domain, EqualityIdentifierComparer); DomainConstraint constraint = new DomainConstraint(variable, range); DomainTermExpr result = new DomainTermExpr(EqualityComparer <DomainConstraint> .Default, constraint); return(result); }
internal override StringBuilder VisitTerm(DomainTermExpr expression) { // If m_skipIsNotNull is true at this point, it means that no ancestor of this // node is OR or NOT BoolLiteral literal = BoolExpression.GetBoolLiteral(expression); if (literal is ScalarRestriction || literal is TypeRestriction) { return(literal.AsUserString(m_builder, Strings.ViewGen_EntityInstanceToken, m_skipIsNotNull)); } return(literal.AsUserString(m_builder, m_blockAlias, m_skipIsNotNull)); }
/// <summary> /// See <see cref="BoolLiteral.IsIdentifierEqualTo"/>. Member restriction can be incomplete for this operation. /// </summary> protected override bool IsIdentifierEqualTo(BoolLiteral right) { MemberRestriction rightOneOfConst = right as MemberRestriction; if (rightOneOfConst == null) { return(false); } if (object.ReferenceEquals(this, rightOneOfConst)) { return(true); } return(MemberProjectedSlot.EqualityComparer.Equals(m_restrictedMemberSlot, rightOneOfConst.m_restrictedMemberSlot)); }
/// <summary> /// See <see cref="BoolLiteral.IsEqualTo"/>. Member restriction can be incomplete for this operation. /// </summary> protected override bool IsEqualTo(BoolLiteral right) { MemberRestriction rightRestriction = right as MemberRestriction; if (rightRestriction == null) { return(false); } if (object.ReferenceEquals(this, rightRestriction)) { return(true); } if (false == MemberProjectedSlot.EqualityComparer.Equals(m_restrictedMemberSlot, rightRestriction.m_restrictedMemberSlot)) { return(false); } return(m_domain.IsEqualTo(rightRestriction.m_domain)); }
// 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) { List <BoolExpression> atoms = new List <BoolExpression>(); foreach (BoolExpression atom in WhereClause.Atoms) { BoolLiteral literal = atom.AsLiteral; MemberRestriction 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. IEnumerable <Constant> possibleValues = domainMap.GetDomain(restriction.RestrictedMemberSlot.MemberPath); MemberRestriction 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 ScalarRestriction scalarConst = restriction as ScalarRestriction; bool 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()); } }
internal override StringBuilder VisitNot(DomainNotExpr expression) { m_skipIsNotNull = false; // Cannot skip in NOTs DomainTermExpr termExpr = expression.Child as DomainTermExpr; if (termExpr != null) { BoolLiteral literal = BoolExpression.GetBoolLiteral(termExpr); return(literal.AsNegatedUserString(m_builder, m_blockAlias, m_skipIsNotNull)); } else { m_builder.Append("NOT("); // We do not need the returned StringBuilder -- it is the same as m_builder expression.Child.Accept(this); m_builder.Append(")"); } return(m_builder); }
/// <summary> /// Checks if the identifier in this is the same as the one in <paramref name="right"/>. /// </summary> protected virtual bool IsIdentifierEqualTo(BoolLiteral right) { return(IsEqualTo(right)); }
protected abstract T_Return BooleanLiteralAsCql(BoolLiteral literal, bool skipIsNotNull);
protected override DbExpression BooleanLiteralAsCql(BoolLiteral literal, bool skipIsNotNull) { return(literal.AsCqt(m_row, skipIsNotNull)); }
// effects: Create a boolean expression from a literal value internal static BoolExpression CreateLiteral(BoolLiteral literal, MemberDomainMap memberDomainMap) { DomainBoolExpr expr = literal.GetDomainBoolExpression(memberDomainMap); return(new BoolExpression(expr, memberDomainMap)); }
protected abstract bool IsEqualTo(BoolLiteral right);
// effects: Creates a new boolean expression using the memberDomainMap of this expression internal BoolExpression Create(BoolLiteral literal) { DomainBoolExpr expr = literal.GetDomainBoolExpression(m_memberDomainMap); return(new BoolExpression(expr, m_memberDomainMap)); }
protected override StringBuilder BooleanLiteralAsCql(BoolLiteral literal, bool skipIsNotNull) { return(literal.AsEsql(m_builder, m_blockAlias, skipIsNotNull)); }