Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Map / ViewGeneration / Structures / Domain.cs / 1305376 / Domain.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Data.Common.Utils;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Data.Metadata.Edm;
using System.Data.Mapping.ViewGeneration.Utils;
using System.Linq;
using System.Data.Entity;
namespace System.Data.Mapping.ViewGeneration.Structures
{
using CellConstantSet = Set;
// A set of cell constants -- to keep track of a cell constant's domain
// values. It encapsulates the notions of NULL, NOT NULL and can be
// enhanced in the future with more functionality
// To represent "infinite" domains such as integer, a special constant CellConstant.NotNull is used.
// For example: domain of System.Boolean is {true, false}, domain of
// (nullable) System.Int32 property is {Null, NotNull}.
internal class Domain : InternalBase
{
#region Constructors
// effects: Creates an "fully-done" set with no values -- possibleDiscreteValues are the values
// that this domain can take
internal Domain(Constant value, IEnumerable possibleDiscreteValues) :
this(new Constant[] { value }, possibleDiscreteValues)
{
}
// effects: Creates a domain populated using values -- possibleValues
// are all possible values that this can take
internal Domain(IEnumerable values,
IEnumerable possibleDiscreteValues)
{
// Note that the values can contain both null and not null
Debug.Assert(values != null);
Debug.Assert(possibleDiscreteValues != null);
// Determine the possibleValues first and then create the negatedConstant
m_possibleValues = DeterminePossibleValues(values, possibleDiscreteValues);
// Now we need to make sure that m_domain is correct. if "values" (v) already has
// the negated stuff, we need to make sure it is in conformance
// with what m_possibleValues (p) has
// For NOT --> Add all constants into d that are present in p but
// not in the NOT
// v = 1, NOT(1, 2); p = 1, 2, 3 => d = 1, NOT(1, 2, 3), 3
// v = 1, 2, NOT(1); p = 1, 2, 4 => d = 1, 2, 4, NOT(1, 2, 4)
// v = 1, 2, NOT(1, 2, 4), NOT(1, 2, 4, 5); p = 1, 2, 4, 5, 6 =>
// d = 1, 2, 5, 6, NOT(1, 2, 4, 5, 6)
// NotNull works naturally now. If possibleValues has (1, 2,
// NULL) and values has NOT(NULL), add 1, 2 to m_domain
m_domain = ExpandNegationsInDomain(values, m_possibleValues);
AssertInvariant();
}
// effects: Creates a copy of the set "domain"
internal Domain(Domain domain)
{
m_domain = new Set(domain.m_domain, Constant.EqualityComparer);
m_possibleValues = new Set(domain.m_possibleValues, Constant.EqualityComparer);
AssertInvariant();
}
#endregion
#region Fields
// The set of values in the cell constant domain
private CellConstantSet m_domain; // e.g., 1, 2, NULL, NOT(1, 2, NULL)
private CellConstantSet m_possibleValues; // e.g., 1, 2, NULL, Undefined
// Invariant: m_domain is a subset of m_possibleValues except for a
// negated constant
#endregion
#region Properties
// effects: Returns all the possible values that this can contain (including the negated constants)
internal IEnumerable AllPossibleValues
{
get { return AllPossibleValuesInternal; }
}
// effects: Returns all the possible values that this can contain (including the negated constants)
private Set AllPossibleValuesInternal
{
get
{
NegatedConstant negatedPossibleValue = new NegatedConstant(m_possibleValues);
return m_possibleValues.Union(new Constant[] { negatedPossibleValue });
}
}
// effects: Returns the number of constants in this (including a negated constant)
internal int Count
{
get { return m_domain.Count; }
}
// effects: Yields all the values in this
internal IEnumerable Values
{
get { return m_domain; }
}
#endregion
#region Static Helper Methods to create cell constant sets from metadata
// effects: Given a member, determines all possible values that can be created from Metadata
internal static CellConstantSet DeriveDomainFromMemberPath(MemberPath memberPath, EdmItemCollection edmItemCollection, bool leaveDomainUnbounded)
{
CellConstantSet domain = DeriveDomainFromType(memberPath.EdmType, edmItemCollection, leaveDomainUnbounded);
if (memberPath.IsNullable)
{
domain.Add(Constant.Null);
}
return domain;
}
// effects: Given a type, determines all possible values that can be created from Metadata
private static CellConstantSet DeriveDomainFromType(EdmType type, EdmItemCollection edmItemCollection, bool leaveDomainUnbounded)
{
CellConstantSet domain = null;
PrimitiveType scalarType = type as PrimitiveType;
EnumType enumType = type as EnumType;
if (scalarType != null) //if Scalar Type
{
// Get the domain for scalars -- for booleans, we special case.
if (scalarType.PrimitiveTypeKind == PrimitiveTypeKind.Boolean)
{
// Closed domain
domain = new Set(CreateList(true, false), Constant.EqualityComparer);
}
else
{
// Unbounded domain
domain = new Set(Constant.EqualityComparer);
if (leaveDomainUnbounded)
{
domain.Add(Constant.NotNull);
}
}
}
else if (enumType != null) //If Enumeration Type
{
// Get all the values for the enumeration
domain = GetEnumeratedDomain(enumType);
}
else //Type Constants - Domain is all possible concrete subtypes
{
Debug.Assert(Helper.IsEntityType(type) || Helper.IsComplexType(type) || Helper.IsRefType(type) || Helper.IsAssociationType(type));
// Treat ref types as their referenced entity types
if (Helper.IsRefType(type))
{
type = ((RefType)type).ElementType;
}
List types = new List();
foreach (EdmType derivedType in MetadataHelper.GetTypeAndSubtypesOf(type, edmItemCollection, false /*includeAbstractTypes*/))
{
TypeConstant derivedTypeConstant = new TypeConstant(derivedType);
types.Add(derivedTypeConstant);
}
domain = new Set(types, Constant.EqualityComparer);
}
Debug.Assert(domain != null, "Domain not set up for some type");
return domain;
}
// effect: returns the default value for the member
// if the member is nullable and has no default, changes default value to CellConstant.NULL and returns true
// if the mebmer is not nullable and has no default, returns false
// CHANGE_[....]_FEATURE_DEFAULT_VALUES: return the right default once metadata supports it
internal static bool TryGetDefaultValueForMemberPath(MemberPath memberPath, out Constant defaultConstant)
{
object defaultValue = memberPath.DefaultValue;
defaultConstant = Constant.Null;
if (defaultValue != null)
{
defaultConstant = new ScalarConstant(defaultValue);
return true;
}
else if (memberPath.IsNullable || memberPath.IsComputed)
{
return true;
}
return false;
}
internal static Constant GetDefaultValueForMemberPath(MemberPath memberPath, IEnumerable wrappersForErrorReporting,
ConfigViewGenerator config)
{
Constant defaultValue = null;
if (!Domain.TryGetDefaultValueForMemberPath(memberPath, out defaultValue))
{
string message = Strings.ViewGen_No_Default_Value_1(memberPath.Extent.Name, memberPath.PathToString(false));
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.NoDefaultValue, message, wrappersForErrorReporting, String.Empty);
ExceptionHelpers.ThrowMappingException(record, config);
}
return defaultValue;
}
// effects: Given an enumeration type, enumType, returns the set of
// values that enumType can take
private static CellConstantSet GetEnumeratedDomain(EnumType enumType)
{
Set values = new Set(Constant.EqualityComparer);
foreach (EnumMember enumerationValue in enumType.EnumMembers)
{
values.Add(new ScalarConstant(enumerationValue));
}
return values;
}
#endregion
#region External methods
internal int GetHash()
{
int result = 0;
foreach (Constant constant in m_domain)
{
result ^= Constant.EqualityComparer.GetHashCode(constant);
}
return result;
}
// effects: Returns true iff this domain has the same values as
// second. Note that this method performs a semantic check not just
// an element by element check
internal bool IsEqualTo(Domain second)
{
return m_domain.SetEquals(second.m_domain);
}
// requires: this is fully done
// effects: Returns true iff this contains NOT(NULL OR ....)
internal bool ContainsNotNull()
{
NegatedConstant negated = GetNegatedConstant(m_domain);
return negated != null && negated.Contains(Constant.Null);
}
///
/// Returns true if the domain contains the given Cell Constant
///
internal bool Contains(Constant constant)
{
return m_domain.Contains(constant);
}
// effects: Given a set of values in domain, "normalizes" it, i.e.,
// all positive constants are seperated out and any negative constant
// is changed s.t. it is the negative of all positive values
// extraValues indicates more constants that domain could take, e.g.,
// domain could be "1, 2, NOT(1, 2)", extraValues could be "3". In
// this case, we return "1, 2, 3, NOT(1, 2, 3)"
internal static CellConstantSet ExpandNegationsInDomain(IEnumerable domain, IEnumerable otherPossibleValues)
{
//Finds all constants referenced in (domain UNION extraValues) e.g: 1, NOT(2) => 1, 2
CellConstantSet possibleValues = DeterminePossibleValues(domain, otherPossibleValues);
// For NOT --> Add all constants into d that are present in p but
// not in the NOT
// v = 1, NOT(1, 2); p = 1, 2, 3 => d = 1, NOT(1, 2, 3), 3
// v = 1, 2, NOT(1); p = 1, 2, 4 => d = 1, 2, 4, NOT(1, 2, 4)
// v = 1, 2, NOT(1, 2, 4), NOT(1, 2, 4, 5); p = 1, 2, 4, 5, 6 => d = 1, 2, 5, 6, NOT(1, 2, 4, 5, 6)
// NotNull works naturally now. If possibleValues has (1, 2, NULL)
// and values has NOT(NULL), add 1, 2 to m_domain
CellConstantSet result = new Set(Constant.EqualityComparer);
foreach (Constant constant in domain)
{
NegatedConstant negated = constant as NegatedConstant;
if (negated != null)
{
result.Add(new NegatedConstant(possibleValues));
// Compute all elements in possibleValues that are not present in negated. E.g., if
// negated is NOT(1, 2, 3) and possibleValues is 1, 2, 3,
// 4, we need to add 4 to result
CellConstantSet remainingElements = possibleValues.Difference(negated.Elements);
result.AddRange(remainingElements);
}
else
{
result.Add(constant);
}
}
return result;
}
internal static CellConstantSet ExpandNegationsInDomain(IEnumerable domain)
{
return ExpandNegationsInDomain(domain, domain);
}
// effects: Given a set of values in domain
// Returns all possible values that are present in domain.
static CellConstantSet DeterminePossibleValues(IEnumerable domain)
{
// E.g., if we have 1, 2, NOT(1) --> Result = 1, 2
// 1, NOT(1, 2) --> Result = 1, 2
// 1, 2, NOT(NULL) --> Result = 1, 2, NULL
// 1, 2, NOT(2), NOT(3, 4) --> Result = 1, 2, 3, 4
CellConstantSet result = new CellConstantSet(Constant.EqualityComparer);
foreach (Constant constant in domain)
{
NegatedConstant negated = constant as NegatedConstant;
if (negated != null)
{
// Go through all the constants in negated and add them to domain
// We add them to possible values also even if (say) Null is not allowed because we want the complete
// partitioning of the space, e.g., if the values specified by the caller are 1, NotNull -> we want 1, Null
foreach (Constant constElement in negated.Elements)
{
Debug.Assert(constElement as NegatedConstant == null, "Negated cell constant inside NegatedCellConstant");
result.Add(constElement);
}
}
else
{
result.Add(constant);
}
}
return result;
}
#endregion
#region Helper methods for determining domains from cells
// effects: Given a set of cells, returns all the different values
// that each memberPath in cells can take
internal static Dictionary
ComputeConstantDomainSetsForSlotsInQueryViews(IEnumerable cells, EdmItemCollection edmItemCollection, bool isValidationEnabled)
{
Dictionary cDomainMap =
new Dictionary(MemberPath.EqualityComparer);
foreach (Cell cell in cells)
{
CellQuery cQuery = cell.CQuery;
// Go through the conjuncts to get the constants (e.g., we
// just don't want to NULL, NOT(NULL). We want to say that
// the possible values are NULL, 4, NOT(NULL, 4)
foreach (MemberRestriction restriction in cQuery.GetConjunctsFromWhereClause())
{
MemberProjectedSlot slot = restriction.RestrictedMemberSlot;
CellConstantSet cDomain = DeriveDomainFromMemberPath(slot.MemberPath, edmItemCollection, isValidationEnabled);
// Now we add the domain of oneConst into this
//Isnull=true and Isnull=false conditions should not contribute to a member's domain
cDomain.AddRange(restriction.Domain.Values.Where(c => !(c.Equals(Constant.Null) || c.Equals(Constant.NotNull))));
CellConstantSet values;
bool found = cDomainMap.TryGetValue(slot.MemberPath, out values);
if (!found)
{
cDomainMap[slot.MemberPath] = cDomain;
}
else
{
values.AddRange(cDomain);
}
}
}
return cDomainMap;
}
//True = domain is restricted, False = domain is not restricted (because there is no condition)
private static bool GetRestrictedOrUnrestrictedDomain(MemberProjectedSlot slot, CellQuery cellQuery, EdmItemCollection edmItemCollection, out CellConstantSet domain)
{
CellConstantSet domainValues = DeriveDomainFromMemberPath(slot.MemberPath, edmItemCollection, true /* leaveDomainUnbounded */);
//Note, out domain is set even in the case where method call returns false
return TryGetDomainRestrictedByWhereClause(domainValues, slot, cellQuery, out domain);
}
// effects: returns a dictionary that maps each S-side slot whose domain can be restricted to such an enumerated domain
// The resulting domain is a union of
// (a) constants appearing in conditions on that slot on S-side
// (b) constants appearing in conditions on the respective slot on C-side, if the given slot
// is projected (on the C-side) and no conditions are placed on it on S-side
// (c) default value of the slot based on metadata
internal static Dictionary
ComputeConstantDomainSetsForSlotsInUpdateViews(IEnumerable cells, EdmItemCollection edmItemCollection)
{
Dictionary updateDomainMap = new Dictionary(MemberPath.EqualityComparer);
foreach (Cell cell in cells)
{
CellQuery cQuery = cell.CQuery;
CellQuery sQuery = cell.SQuery;
foreach (MemberProjectedSlot sSlot in sQuery.GetConjunctsFromWhereClause().Select(oneOfConst => oneOfConst.RestrictedMemberSlot))
{
// obtain initial slot domain and restrict it if the slot has conditions
CellConstantSet restrictedDomain;
bool wasDomainRestricted = GetRestrictedOrUnrestrictedDomain(sSlot, sQuery, edmItemCollection, out restrictedDomain);
// Suppose that we have a cell:
// Proj(ID, A) WHERE(A=5) FROM E = Proj(ID, B) FROM T
// In the above cell, B on the S-side is 5 and we add that to its range. But if B had a restriction,
// we do not add 5. Note that do we not have a problem w.r.t. possibleValues since if A=5 and B=1, we have an
// empty cell -- we should catch that as an error. If A = 5 and B = 5 is present then restrictedDomain
// and domainValues are the same
// if no restriction on the S-side and the slot is projected then take the domain from the C-side
if (!wasDomainRestricted)
{
int projectedPosition = sQuery.GetProjectedPosition(sSlot);
if (projectedPosition >= 0)
{
// get the domain of the respective C-side slot
MemberProjectedSlot cSlot = cQuery.ProjectedSlotAt(projectedPosition) as MemberProjectedSlot;
Debug.Assert(cSlot != null, "Assuming constants are not projected");
wasDomainRestricted = GetRestrictedOrUnrestrictedDomain(cSlot, cQuery, edmItemCollection, out restrictedDomain);
if (!wasDomainRestricted)
{
continue;
}
}
}
// Add the default value to the domain
MemberPath sSlotMemberPath = sSlot.MemberPath;
Constant defaultValue;
if (TryGetDefaultValueForMemberPath(sSlotMemberPath, out defaultValue))
{
restrictedDomain.Add(defaultValue);
}
// add all constants appearing in the domain to sDomainMap
CellConstantSet sSlotDomain;
if (!updateDomainMap.TryGetValue(sSlotMemberPath, out sSlotDomain))
{
updateDomainMap[sSlotMemberPath] = restrictedDomain;
}
else
{
sSlotDomain.AddRange(restrictedDomain);
}
}
}
return updateDomainMap;
}
// requires: domain not have any Negated constants other than NotNull
// Also, cellQuery contains all final oneOfConsts or all partial oneOfConsts
// cellquery must contain a whereclause of the form "True", "OneOfConst" or "
// "OneOfConst AND ... AND OneOfConst"
// slot must present in cellQuery and incomingDomain is the domain for it
// effects: Returns the set of values that slot can take as restricted by cellQuery's whereClause
private static bool TryGetDomainRestrictedByWhereClause(IEnumerable domain, MemberProjectedSlot slot, CellQuery cellQuery, out CellConstantSet result)
{
var conditionsForSlot = cellQuery.GetConjunctsFromWhereClause()
.Where(restriction => MemberPath.EqualityComparer.Equals(restriction.RestrictedMemberSlot.MemberPath, slot.MemberPath))
.Select(restriction => new CellConstantSet(restriction.Domain.Values, Constant.EqualityComparer));
//Debug.Assert(!conditionsForSlot.Skip(1).Any(), "More than one Clause with the same path");
if (!conditionsForSlot.Any())
{
// If the slot was not mentioned in the query return the domain without restricting it
result = new CellConstantSet(domain);
return false;
}
// Now get all the possible values from domain and conditionValues
CellConstantSet possibleValues = DeterminePossibleValues(conditionsForSlot.SelectMany(m => m.Select(c => c)), domain);
Domain restrictedDomain = new Domain(domain, possibleValues);
foreach (var conditionValues in conditionsForSlot)
{
// Domain derived from Edm-Type INTERSECTED with Conditions
restrictedDomain = restrictedDomain.Intersect(new Domain(conditionValues, possibleValues));
}
result = new CellConstantSet(restrictedDomain.Values, Constant.EqualityComparer);
return !domain.SequenceEqual(result);
}
#endregion
#region Private helper methods
// effects: Intersects the values in second with this domain and
// returns the result
private Domain Intersect(Domain second)
{
CheckTwoDomainInvariants(this, second);
Domain result = new Domain(this);
result.m_domain.Intersect(second.m_domain);
return result;
}
// requires: constants has at most one NegatedCellConstant
// effects: Returns the NegatedCellConstant in this if any. Else
// returns null
private static NegatedConstant GetNegatedConstant(IEnumerable constants)
{
NegatedConstant result = null;
foreach (Constant constant in constants)
{
NegatedConstant negated = constant as NegatedConstant;
if (negated != null)
{
Debug.Assert(result == null, "Multiple negated cell constants?");
result = negated;
}
}
return result;
}
// effects: Given a set of values in domain1 and domain2,
// Returns all possible positive values that are present in domain1 and domain2
private static CellConstantSet DeterminePossibleValues(IEnumerable domain1, IEnumerable domain2)
{
CellConstantSet union = new CellConstantSet(domain1, Constant.EqualityComparer).Union(domain2);
CellConstantSet result = DeterminePossibleValues(union);
return result;
}
// effects: Checks that two domains, domain1 and domain2, that are being compared/unioned/intersected, etc
// are compatible with each other
[Conditional("DEBUG")]
private static void CheckTwoDomainInvariants(Domain domain1, Domain domain2)
{
domain1.AssertInvariant();
domain2.AssertInvariant();
// The possible values must match
Debug.Assert(domain1.m_possibleValues.SetEquals(domain2.m_possibleValues), "domains must be compatible");
}
// effects: A helper method. Given two
// values, yields a list of CellConstants in the order of values
private static IEnumerable CreateList(object value1, object value2)
{
yield return new ScalarConstant(value1);
yield return new ScalarConstant(value2);
}
// effects: Checks the invariants in "this"
internal void AssertInvariant()
{
// Make sure m_domain has at most one negatedCellConstant
// m_possibleValues has none
NegatedConstant negated = GetNegatedConstant(m_domain); // Can be null or not-null
negated = GetNegatedConstant(m_possibleValues);
Debug.Assert(negated == null, "m_possibleValues cannot contain negated constant");
Debug.Assert(m_domain.IsSubsetOf(AllPossibleValuesInternal),
"All domain values must be contained in possibleValues");
}
#endregion
#region String methods
// effects: Returns a user-friendly string that can be reported to an end-user
internal string ToUserString()
{
StringBuilder builder = new StringBuilder();
bool isFirst = true;
foreach (Constant constant in m_domain)
{
if (isFirst == false)
{
builder.Append(", ");
}
builder.Append(constant.ToUserString());
isFirst = false;
}
return builder.ToString();
}
internal override void ToCompactString(StringBuilder builder)
{
builder.Append(ToUserString());
}
#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.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Data.Metadata.Edm;
using System.Data.Mapping.ViewGeneration.Utils;
using System.Linq;
using System.Data.Entity;
namespace System.Data.Mapping.ViewGeneration.Structures
{
using CellConstantSet = Set;
// A set of cell constants -- to keep track of a cell constant's domain
// values. It encapsulates the notions of NULL, NOT NULL and can be
// enhanced in the future with more functionality
// To represent "infinite" domains such as integer, a special constant CellConstant.NotNull is used.
// For example: domain of System.Boolean is {true, false}, domain of
// (nullable) System.Int32 property is {Null, NotNull}.
internal class Domain : InternalBase
{
#region Constructors
// effects: Creates an "fully-done" set with no values -- possibleDiscreteValues are the values
// that this domain can take
internal Domain(Constant value, IEnumerable possibleDiscreteValues) :
this(new Constant[] { value }, possibleDiscreteValues)
{
}
// effects: Creates a domain populated using values -- possibleValues
// are all possible values that this can take
internal Domain(IEnumerable values,
IEnumerable possibleDiscreteValues)
{
// Note that the values can contain both null and not null
Debug.Assert(values != null);
Debug.Assert(possibleDiscreteValues != null);
// Determine the possibleValues first and then create the negatedConstant
m_possibleValues = DeterminePossibleValues(values, possibleDiscreteValues);
// Now we need to make sure that m_domain is correct. if "values" (v) already has
// the negated stuff, we need to make sure it is in conformance
// with what m_possibleValues (p) has
// For NOT --> Add all constants into d that are present in p but
// not in the NOT
// v = 1, NOT(1, 2); p = 1, 2, 3 => d = 1, NOT(1, 2, 3), 3
// v = 1, 2, NOT(1); p = 1, 2, 4 => d = 1, 2, 4, NOT(1, 2, 4)
// v = 1, 2, NOT(1, 2, 4), NOT(1, 2, 4, 5); p = 1, 2, 4, 5, 6 =>
// d = 1, 2, 5, 6, NOT(1, 2, 4, 5, 6)
// NotNull works naturally now. If possibleValues has (1, 2,
// NULL) and values has NOT(NULL), add 1, 2 to m_domain
m_domain = ExpandNegationsInDomain(values, m_possibleValues);
AssertInvariant();
}
// effects: Creates a copy of the set "domain"
internal Domain(Domain domain)
{
m_domain = new Set(domain.m_domain, Constant.EqualityComparer);
m_possibleValues = new Set(domain.m_possibleValues, Constant.EqualityComparer);
AssertInvariant();
}
#endregion
#region Fields
// The set of values in the cell constant domain
private CellConstantSet m_domain; // e.g., 1, 2, NULL, NOT(1, 2, NULL)
private CellConstantSet m_possibleValues; // e.g., 1, 2, NULL, Undefined
// Invariant: m_domain is a subset of m_possibleValues except for a
// negated constant
#endregion
#region Properties
// effects: Returns all the possible values that this can contain (including the negated constants)
internal IEnumerable AllPossibleValues
{
get { return AllPossibleValuesInternal; }
}
// effects: Returns all the possible values that this can contain (including the negated constants)
private Set AllPossibleValuesInternal
{
get
{
NegatedConstant negatedPossibleValue = new NegatedConstant(m_possibleValues);
return m_possibleValues.Union(new Constant[] { negatedPossibleValue });
}
}
// effects: Returns the number of constants in this (including a negated constant)
internal int Count
{
get { return m_domain.Count; }
}
// effects: Yields all the values in this
internal IEnumerable Values
{
get { return m_domain; }
}
#endregion
#region Static Helper Methods to create cell constant sets from metadata
// effects: Given a member, determines all possible values that can be created from Metadata
internal static CellConstantSet DeriveDomainFromMemberPath(MemberPath memberPath, EdmItemCollection edmItemCollection, bool leaveDomainUnbounded)
{
CellConstantSet domain = DeriveDomainFromType(memberPath.EdmType, edmItemCollection, leaveDomainUnbounded);
if (memberPath.IsNullable)
{
domain.Add(Constant.Null);
}
return domain;
}
// effects: Given a type, determines all possible values that can be created from Metadata
private static CellConstantSet DeriveDomainFromType(EdmType type, EdmItemCollection edmItemCollection, bool leaveDomainUnbounded)
{
CellConstantSet domain = null;
PrimitiveType scalarType = type as PrimitiveType;
EnumType enumType = type as EnumType;
if (scalarType != null) //if Scalar Type
{
// Get the domain for scalars -- for booleans, we special case.
if (scalarType.PrimitiveTypeKind == PrimitiveTypeKind.Boolean)
{
// Closed domain
domain = new Set(CreateList(true, false), Constant.EqualityComparer);
}
else
{
// Unbounded domain
domain = new Set(Constant.EqualityComparer);
if (leaveDomainUnbounded)
{
domain.Add(Constant.NotNull);
}
}
}
else if (enumType != null) //If Enumeration Type
{
// Get all the values for the enumeration
domain = GetEnumeratedDomain(enumType);
}
else //Type Constants - Domain is all possible concrete subtypes
{
Debug.Assert(Helper.IsEntityType(type) || Helper.IsComplexType(type) || Helper.IsRefType(type) || Helper.IsAssociationType(type));
// Treat ref types as their referenced entity types
if (Helper.IsRefType(type))
{
type = ((RefType)type).ElementType;
}
List types = new List();
foreach (EdmType derivedType in MetadataHelper.GetTypeAndSubtypesOf(type, edmItemCollection, false /*includeAbstractTypes*/))
{
TypeConstant derivedTypeConstant = new TypeConstant(derivedType);
types.Add(derivedTypeConstant);
}
domain = new Set(types, Constant.EqualityComparer);
}
Debug.Assert(domain != null, "Domain not set up for some type");
return domain;
}
// effect: returns the default value for the member
// if the member is nullable and has no default, changes default value to CellConstant.NULL and returns true
// if the mebmer is not nullable and has no default, returns false
// CHANGE_[....]_FEATURE_DEFAULT_VALUES: return the right default once metadata supports it
internal static bool TryGetDefaultValueForMemberPath(MemberPath memberPath, out Constant defaultConstant)
{
object defaultValue = memberPath.DefaultValue;
defaultConstant = Constant.Null;
if (defaultValue != null)
{
defaultConstant = new ScalarConstant(defaultValue);
return true;
}
else if (memberPath.IsNullable || memberPath.IsComputed)
{
return true;
}
return false;
}
internal static Constant GetDefaultValueForMemberPath(MemberPath memberPath, IEnumerable wrappersForErrorReporting,
ConfigViewGenerator config)
{
Constant defaultValue = null;
if (!Domain.TryGetDefaultValueForMemberPath(memberPath, out defaultValue))
{
string message = Strings.ViewGen_No_Default_Value_1(memberPath.Extent.Name, memberPath.PathToString(false));
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.NoDefaultValue, message, wrappersForErrorReporting, String.Empty);
ExceptionHelpers.ThrowMappingException(record, config);
}
return defaultValue;
}
// effects: Given an enumeration type, enumType, returns the set of
// values that enumType can take
private static CellConstantSet GetEnumeratedDomain(EnumType enumType)
{
Set values = new Set(Constant.EqualityComparer);
foreach (EnumMember enumerationValue in enumType.EnumMembers)
{
values.Add(new ScalarConstant(enumerationValue));
}
return values;
}
#endregion
#region External methods
internal int GetHash()
{
int result = 0;
foreach (Constant constant in m_domain)
{
result ^= Constant.EqualityComparer.GetHashCode(constant);
}
return result;
}
// effects: Returns true iff this domain has the same values as
// second. Note that this method performs a semantic check not just
// an element by element check
internal bool IsEqualTo(Domain second)
{
return m_domain.SetEquals(second.m_domain);
}
// requires: this is fully done
// effects: Returns true iff this contains NOT(NULL OR ....)
internal bool ContainsNotNull()
{
NegatedConstant negated = GetNegatedConstant(m_domain);
return negated != null && negated.Contains(Constant.Null);
}
///
/// Returns true if the domain contains the given Cell Constant
///
internal bool Contains(Constant constant)
{
return m_domain.Contains(constant);
}
// effects: Given a set of values in domain, "normalizes" it, i.e.,
// all positive constants are seperated out and any negative constant
// is changed s.t. it is the negative of all positive values
// extraValues indicates more constants that domain could take, e.g.,
// domain could be "1, 2, NOT(1, 2)", extraValues could be "3". In
// this case, we return "1, 2, 3, NOT(1, 2, 3)"
internal static CellConstantSet ExpandNegationsInDomain(IEnumerable domain, IEnumerable otherPossibleValues)
{
//Finds all constants referenced in (domain UNION extraValues) e.g: 1, NOT(2) => 1, 2
CellConstantSet possibleValues = DeterminePossibleValues(domain, otherPossibleValues);
// For NOT --> Add all constants into d that are present in p but
// not in the NOT
// v = 1, NOT(1, 2); p = 1, 2, 3 => d = 1, NOT(1, 2, 3), 3
// v = 1, 2, NOT(1); p = 1, 2, 4 => d = 1, 2, 4, NOT(1, 2, 4)
// v = 1, 2, NOT(1, 2, 4), NOT(1, 2, 4, 5); p = 1, 2, 4, 5, 6 => d = 1, 2, 5, 6, NOT(1, 2, 4, 5, 6)
// NotNull works naturally now. If possibleValues has (1, 2, NULL)
// and values has NOT(NULL), add 1, 2 to m_domain
CellConstantSet result = new Set(Constant.EqualityComparer);
foreach (Constant constant in domain)
{
NegatedConstant negated = constant as NegatedConstant;
if (negated != null)
{
result.Add(new NegatedConstant(possibleValues));
// Compute all elements in possibleValues that are not present in negated. E.g., if
// negated is NOT(1, 2, 3) and possibleValues is 1, 2, 3,
// 4, we need to add 4 to result
CellConstantSet remainingElements = possibleValues.Difference(negated.Elements);
result.AddRange(remainingElements);
}
else
{
result.Add(constant);
}
}
return result;
}
internal static CellConstantSet ExpandNegationsInDomain(IEnumerable domain)
{
return ExpandNegationsInDomain(domain, domain);
}
// effects: Given a set of values in domain
// Returns all possible values that are present in domain.
static CellConstantSet DeterminePossibleValues(IEnumerable domain)
{
// E.g., if we have 1, 2, NOT(1) --> Result = 1, 2
// 1, NOT(1, 2) --> Result = 1, 2
// 1, 2, NOT(NULL) --> Result = 1, 2, NULL
// 1, 2, NOT(2), NOT(3, 4) --> Result = 1, 2, 3, 4
CellConstantSet result = new CellConstantSet(Constant.EqualityComparer);
foreach (Constant constant in domain)
{
NegatedConstant negated = constant as NegatedConstant;
if (negated != null)
{
// Go through all the constants in negated and add them to domain
// We add them to possible values also even if (say) Null is not allowed because we want the complete
// partitioning of the space, e.g., if the values specified by the caller are 1, NotNull -> we want 1, Null
foreach (Constant constElement in negated.Elements)
{
Debug.Assert(constElement as NegatedConstant == null, "Negated cell constant inside NegatedCellConstant");
result.Add(constElement);
}
}
else
{
result.Add(constant);
}
}
return result;
}
#endregion
#region Helper methods for determining domains from cells
// effects: Given a set of cells, returns all the different values
// that each memberPath in cells can take
internal static Dictionary
ComputeConstantDomainSetsForSlotsInQueryViews(IEnumerable cells, EdmItemCollection edmItemCollection, bool isValidationEnabled)
{
Dictionary cDomainMap =
new Dictionary(MemberPath.EqualityComparer);
foreach (Cell cell in cells)
{
CellQuery cQuery = cell.CQuery;
// Go through the conjuncts to get the constants (e.g., we
// just don't want to NULL, NOT(NULL). We want to say that
// the possible values are NULL, 4, NOT(NULL, 4)
foreach (MemberRestriction restriction in cQuery.GetConjunctsFromWhereClause())
{
MemberProjectedSlot slot = restriction.RestrictedMemberSlot;
CellConstantSet cDomain = DeriveDomainFromMemberPath(slot.MemberPath, edmItemCollection, isValidationEnabled);
// Now we add the domain of oneConst into this
//Isnull=true and Isnull=false conditions should not contribute to a member's domain
cDomain.AddRange(restriction.Domain.Values.Where(c => !(c.Equals(Constant.Null) || c.Equals(Constant.NotNull))));
CellConstantSet values;
bool found = cDomainMap.TryGetValue(slot.MemberPath, out values);
if (!found)
{
cDomainMap[slot.MemberPath] = cDomain;
}
else
{
values.AddRange(cDomain);
}
}
}
return cDomainMap;
}
//True = domain is restricted, False = domain is not restricted (because there is no condition)
private static bool GetRestrictedOrUnrestrictedDomain(MemberProjectedSlot slot, CellQuery cellQuery, EdmItemCollection edmItemCollection, out CellConstantSet domain)
{
CellConstantSet domainValues = DeriveDomainFromMemberPath(slot.MemberPath, edmItemCollection, true /* leaveDomainUnbounded */);
//Note, out domain is set even in the case where method call returns false
return TryGetDomainRestrictedByWhereClause(domainValues, slot, cellQuery, out domain);
}
// effects: returns a dictionary that maps each S-side slot whose domain can be restricted to such an enumerated domain
// The resulting domain is a union of
// (a) constants appearing in conditions on that slot on S-side
// (b) constants appearing in conditions on the respective slot on C-side, if the given slot
// is projected (on the C-side) and no conditions are placed on it on S-side
// (c) default value of the slot based on metadata
internal static Dictionary
ComputeConstantDomainSetsForSlotsInUpdateViews(IEnumerable cells, EdmItemCollection edmItemCollection)
{
Dictionary updateDomainMap = new Dictionary(MemberPath.EqualityComparer);
foreach (Cell cell in cells)
{
CellQuery cQuery = cell.CQuery;
CellQuery sQuery = cell.SQuery;
foreach (MemberProjectedSlot sSlot in sQuery.GetConjunctsFromWhereClause().Select(oneOfConst => oneOfConst.RestrictedMemberSlot))
{
// obtain initial slot domain and restrict it if the slot has conditions
CellConstantSet restrictedDomain;
bool wasDomainRestricted = GetRestrictedOrUnrestrictedDomain(sSlot, sQuery, edmItemCollection, out restrictedDomain);
// Suppose that we have a cell:
// Proj(ID, A) WHERE(A=5) FROM E = Proj(ID, B) FROM T
// In the above cell, B on the S-side is 5 and we add that to its range. But if B had a restriction,
// we do not add 5. Note that do we not have a problem w.r.t. possibleValues since if A=5 and B=1, we have an
// empty cell -- we should catch that as an error. If A = 5 and B = 5 is present then restrictedDomain
// and domainValues are the same
// if no restriction on the S-side and the slot is projected then take the domain from the C-side
if (!wasDomainRestricted)
{
int projectedPosition = sQuery.GetProjectedPosition(sSlot);
if (projectedPosition >= 0)
{
// get the domain of the respective C-side slot
MemberProjectedSlot cSlot = cQuery.ProjectedSlotAt(projectedPosition) as MemberProjectedSlot;
Debug.Assert(cSlot != null, "Assuming constants are not projected");
wasDomainRestricted = GetRestrictedOrUnrestrictedDomain(cSlot, cQuery, edmItemCollection, out restrictedDomain);
if (!wasDomainRestricted)
{
continue;
}
}
}
// Add the default value to the domain
MemberPath sSlotMemberPath = sSlot.MemberPath;
Constant defaultValue;
if (TryGetDefaultValueForMemberPath(sSlotMemberPath, out defaultValue))
{
restrictedDomain.Add(defaultValue);
}
// add all constants appearing in the domain to sDomainMap
CellConstantSet sSlotDomain;
if (!updateDomainMap.TryGetValue(sSlotMemberPath, out sSlotDomain))
{
updateDomainMap[sSlotMemberPath] = restrictedDomain;
}
else
{
sSlotDomain.AddRange(restrictedDomain);
}
}
}
return updateDomainMap;
}
// requires: domain not have any Negated constants other than NotNull
// Also, cellQuery contains all final oneOfConsts or all partial oneOfConsts
// cellquery must contain a whereclause of the form "True", "OneOfConst" or "
// "OneOfConst AND ... AND OneOfConst"
// slot must present in cellQuery and incomingDomain is the domain for it
// effects: Returns the set of values that slot can take as restricted by cellQuery's whereClause
private static bool TryGetDomainRestrictedByWhereClause(IEnumerable domain, MemberProjectedSlot slot, CellQuery cellQuery, out CellConstantSet result)
{
var conditionsForSlot = cellQuery.GetConjunctsFromWhereClause()
.Where(restriction => MemberPath.EqualityComparer.Equals(restriction.RestrictedMemberSlot.MemberPath, slot.MemberPath))
.Select(restriction => new CellConstantSet(restriction.Domain.Values, Constant.EqualityComparer));
//Debug.Assert(!conditionsForSlot.Skip(1).Any(), "More than one Clause with the same path");
if (!conditionsForSlot.Any())
{
// If the slot was not mentioned in the query return the domain without restricting it
result = new CellConstantSet(domain);
return false;
}
// Now get all the possible values from domain and conditionValues
CellConstantSet possibleValues = DeterminePossibleValues(conditionsForSlot.SelectMany(m => m.Select(c => c)), domain);
Domain restrictedDomain = new Domain(domain, possibleValues);
foreach (var conditionValues in conditionsForSlot)
{
// Domain derived from Edm-Type INTERSECTED with Conditions
restrictedDomain = restrictedDomain.Intersect(new Domain(conditionValues, possibleValues));
}
result = new CellConstantSet(restrictedDomain.Values, Constant.EqualityComparer);
return !domain.SequenceEqual(result);
}
#endregion
#region Private helper methods
// effects: Intersects the values in second with this domain and
// returns the result
private Domain Intersect(Domain second)
{
CheckTwoDomainInvariants(this, second);
Domain result = new Domain(this);
result.m_domain.Intersect(second.m_domain);
return result;
}
// requires: constants has at most one NegatedCellConstant
// effects: Returns the NegatedCellConstant in this if any. Else
// returns null
private static NegatedConstant GetNegatedConstant(IEnumerable constants)
{
NegatedConstant result = null;
foreach (Constant constant in constants)
{
NegatedConstant negated = constant as NegatedConstant;
if (negated != null)
{
Debug.Assert(result == null, "Multiple negated cell constants?");
result = negated;
}
}
return result;
}
// effects: Given a set of values in domain1 and domain2,
// Returns all possible positive values that are present in domain1 and domain2
private static CellConstantSet DeterminePossibleValues(IEnumerable domain1, IEnumerable domain2)
{
CellConstantSet union = new CellConstantSet(domain1, Constant.EqualityComparer).Union(domain2);
CellConstantSet result = DeterminePossibleValues(union);
return result;
}
// effects: Checks that two domains, domain1 and domain2, that are being compared/unioned/intersected, etc
// are compatible with each other
[Conditional("DEBUG")]
private static void CheckTwoDomainInvariants(Domain domain1, Domain domain2)
{
domain1.AssertInvariant();
domain2.AssertInvariant();
// The possible values must match
Debug.Assert(domain1.m_possibleValues.SetEquals(domain2.m_possibleValues), "domains must be compatible");
}
// effects: A helper method. Given two
// values, yields a list of CellConstants in the order of values
private static IEnumerable CreateList(object value1, object value2)
{
yield return new ScalarConstant(value1);
yield return new ScalarConstant(value2);
}
// effects: Checks the invariants in "this"
internal void AssertInvariant()
{
// Make sure m_domain has at most one negatedCellConstant
// m_possibleValues has none
NegatedConstant negated = GetNegatedConstant(m_domain); // Can be null or not-null
negated = GetNegatedConstant(m_possibleValues);
Debug.Assert(negated == null, "m_possibleValues cannot contain negated constant");
Debug.Assert(m_domain.IsSubsetOf(AllPossibleValuesInternal),
"All domain values must be contained in possibleValues");
}
#endregion
#region String methods
// effects: Returns a user-friendly string that can be reported to an end-user
internal string ToUserString()
{
StringBuilder builder = new StringBuilder();
bool isFirst = true;
foreach (Constant constant in m_domain)
{
if (isFirst == false)
{
builder.Append(", ");
}
builder.Append(constant.ToUserString());
isFirst = false;
}
return builder.ToString();
}
internal override void ToCompactString(StringBuilder builder)
{
builder.Append(ToUserString());
}
#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
- HttpServerProtocol.cs
- EventsTab.cs
- ReleaseInstanceMode.cs
- HttpGetProtocolImporter.cs
- ResourcePermissionBaseEntry.cs
- EventMappingSettingsCollection.cs
- SiteMapPathDesigner.cs
- AlternateViewCollection.cs
- GeneralTransformGroup.cs
- TypographyProperties.cs
- RequiredFieldValidator.cs
- GraphicsState.cs
- ObjectSet.cs
- GridEntryCollection.cs
- StartUpEventArgs.cs
- XmlCodeExporter.cs
- followingquery.cs
- StaticFileHandler.cs
- coordinatorfactory.cs
- OLEDB_Util.cs
- DiscardableAttribute.cs
- NotSupportedException.cs
- HistoryEventArgs.cs
- DataControlField.cs
- FormsAuthenticationEventArgs.cs
- HandoffBehavior.cs
- ListMarkerSourceInfo.cs
- Vector3DCollectionConverter.cs
- TableDetailsRow.cs
- TextReader.cs
- SizeConverter.cs
- TextDocumentView.cs
- ResourcePermissionBaseEntry.cs
- PackagingUtilities.cs
- Parser.cs
- CuspData.cs
- MatchNoneMessageFilter.cs
- formatter.cs
- DBConnection.cs
- SlipBehavior.cs
- ResourceContainer.cs
- ThemeDictionaryExtension.cs
- Storyboard.cs
- TemplateBamlRecordReader.cs
- ToolStripItemClickedEventArgs.cs
- SplitterPanelDesigner.cs
- UncommonField.cs
- XmlExtensionFunction.cs
- AsyncPostBackErrorEventArgs.cs
- SynchronizationLockException.cs
- CompilerHelpers.cs
- Opcode.cs
- FieldBuilder.cs
- XmlDictionary.cs
- TCPListener.cs
- StickyNoteHelper.cs
- StoreAnnotationsMap.cs
- StringStorage.cs
- CLRBindingWorker.cs
- CornerRadius.cs
- CommandDevice.cs
- DateTimeParse.cs
- WorkflowServiceBuildProvider.cs
- SqlDataSourceCustomCommandEditor.cs
- SelectorAutomationPeer.cs
- AliasedExpr.cs
- NavigationWindowAutomationPeer.cs
- InputScopeNameConverter.cs
- ReadOnlyNameValueCollection.cs
- XmlBoundElement.cs
- DataSet.cs
- RuntimeComponentFilter.cs
- BamlTreeUpdater.cs
- TypeConverterValueSerializer.cs
- KeyGestureValueSerializer.cs
- UidPropertyAttribute.cs
- LowerCaseStringConverter.cs
- RegexRunner.cs
- ToolStripItemCollection.cs
- PermissionToken.cs
- bindurihelper.cs
- Empty.cs
- WriteableBitmap.cs
- DbTransaction.cs
- TdsParserStaticMethods.cs
- XPathArrayIterator.cs
- LinkUtilities.cs
- QuadraticBezierSegment.cs
- ServerValidateEventArgs.cs
- EditorBrowsableAttribute.cs
- OptimizedTemplateContent.cs
- ControlIdConverter.cs
- ObjectHandle.cs
- SqlClientWrapperSmiStreamChars.cs
- ReadOnlyDataSourceView.cs
- PathGradientBrush.cs
- EmbeddedMailObject.cs
- SerializeAbsoluteContext.cs
- WsdlWriter.cs
- CanonicalFormWriter.cs