Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Map / ViewGeneration / QueryRewriting / QueryRewriter.cs / 1305376 / QueryRewriter.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Data.Common.Utils;
using System.Collections.Generic;
using System.Data.Mapping.ViewGeneration.Validation;
using System.Data.Mapping.ViewGeneration.Structures;
using System.Text;
using System.Diagnostics;
using System.Collections.ObjectModel;
using System.Data.Mapping.ViewGeneration.Utils;
using System.Data.Metadata.Edm;
using System.Data.Entity;
using System.Data.Common.Utils.Boolean;
using System.Linq;
namespace System.Data.Mapping.ViewGeneration.QueryRewriting
{
///
/// Uses query rewriting to determine the case statements, top-level WHERE clause, and the "used views"
/// for a given type to be generated.
///
/// Step 1: Method "EnsureIsFullyMapped" goes through the (C) schema metadata and checks whether the query for each
/// entity shape can be rewritten from the C fragment queries.
/// This step tracks the "used views" which will later be passed to "basic view generation" (i.e., creation of the FOJ/LOJ/IJ/Union relational expressions)
/// Step 2: GetCaseStatements constructs the required case statements and the top-level WHERE clause.
/// This may add some extra views to "used views".
/// Now we know what views are used overall.
/// Step 3: We remap _from variables to new _from variables that are renumbered for used views.
/// This is done to comply with the numbering scheme in the old algorithm - and to produce more readable views.
/// Step 4: From the constructed relational expression (OpCellTree), we can tell whether a top-level WHERE clause is needed or not.
/// (Usually, it's needed only in certain cases for OfType() views.)
///
internal class QueryRewriter
{
#region Fields
// The following fields are copied from ViewGenContext
MemberPath _extentPath;
MemberDomainMap _domainMap;
ConfigViewGenerator _config;
CqlIdentifiers _identifiers;
ViewgenContext _context;
// Keeps track of statistics
RewritingProcessor> _qp;
// Key attributes of the current extent in _extentPath
List _keyAttributes;
// Fragment queries, one per LeftCellWrapper
List _fragmentQueries = new List();
List> _views = new List>();
FragmentQuery _domainQuery;
EdmType _generatedType;
HashSet _usedViews = new HashSet();
List _usedCells = new List();
BoolExpression _topLevelWhereClause;
CellTreeNode _basicView;
Dictionary _caseStatements = new Dictionary();
ErrorLog _errorLog = new ErrorLog();
ViewGenerationMode _typesGenerationMode;
#endregion
#region Static variables
static Tile TrueViewSurrogate = CreateTile(FragmentQuery.Create(BoolExpression.True));
#endregion
#region Constructor and main entry point
internal QueryRewriter(EdmType generatedType, ViewgenContext context, ViewGenerationMode typesGenerationMode)
{
Debug.Assert(typesGenerationMode != ViewGenerationMode.GenerateAllViews);
_typesGenerationMode = typesGenerationMode;
_context = context;
_generatedType = generatedType;
_domainMap = context.MemberMaps.LeftDomainMap;
_config = context.Config;
_identifiers = context.CqlIdentifiers;
_qp = new RewritingProcessor>(new DefaultTileProcessor(context.LeftFragmentQP));
_extentPath = new MemberPath(context.Extent);
_keyAttributes = new List(MemberPath.GetKeyMembers(context.Extent, _domainMap));
// populate _fragmentQueries and _views
foreach (LeftCellWrapper leftCellWrapper in _context.AllWrappersForExtent)
{
FragmentQuery query = leftCellWrapper.FragmentQuery;
Tile tile = CreateTile(query);
_fragmentQueries.Add(query);
_views.Add(tile);
}
Debug.Assert(_views.Count > 0);
AdjustMemberDomainsForUpdateViews();
// must be done after adjusting domains
_domainQuery = GetDomainQuery(FragmentQueries, generatedType);
_usedViews = new HashSet();
}
// Generates the components used to assemble and validate the view:
// (1) case statements
// (2) top-level where clause
// (3) used cells
// (4) basic view CellTreeNode
// (5) dictionary for validation
internal void GenerateViewComponents()
{
// make sure everything is mapped (for query views only)
EnsureExtentIsFullyMapped(_usedViews);
// (1) case statements
GenerateCaseStatements(_domainMap.ConditionMembers(_extentPath.Extent), _usedViews);
AddTrivialCaseStatementsForConditionMembers();
if (_usedViews.Count == 0 || _errorLog.Count > 0)
{
// can't continue: no view will be generated, further validation doesn't make sense
Debug.Assert(_errorLog.Count > 0);
ExceptionHelpers.ThrowMappingException(_errorLog, _config);
}
// (2) top-level where clause
_topLevelWhereClause = GetTopLevelWhereClause(_usedViews);
// some tracing
if (_context.ViewTarget == ViewTarget.QueryView)
{
TraceVerbose("Used {0} views of {1} total for rewriting", _usedViews.Count, _views.Count);
}
PrintStatistics(_qp);
// (3) construct the final _from variables
_usedCells = RemapFromVariables();
// (4) construct basic view
BasicViewGenerator basicViewGenerator = new BasicViewGenerator(
_context.MemberMaps.ProjectedSlotMap, _usedCells,
_domainQuery, _context, _domainMap, _errorLog, _config);
_basicView = basicViewGenerator.CreateViewExpression();
// a top-level WHERE clause is needed only if the simplifiedView still contains extra tuples
bool noWhereClauseNeeded = _context.LeftFragmentQP.IsContainedIn(_basicView.LeftFragmentQuery, _domainQuery);
if (noWhereClauseNeeded)
{
_topLevelWhereClause = BoolExpression.True;
}
if (_errorLog.Count > 0)
{
ExceptionHelpers.ThrowMappingException(_errorLog, _config);
}
}
#endregion
#region Properties
internal ViewgenContext ViewgenContext
{
get { return _context; }
}
internal Dictionary CaseStatements
{
get { return _caseStatements; }
}
internal BoolExpression TopLevelWhereClause
{
get { return _topLevelWhereClause; }
}
internal CellTreeNode BasicView
{
get
{
// create a copy so the original won't get modified when Simplifier.Simplify is called on it
return _basicView.MakeCopy();
}
}
internal List UsedCells
{
get { return _usedCells; }
}
private IEnumerable FragmentQueries
{
get { return _fragmentQueries; }
}
#endregion
#region Main logic
private IEnumerable GetDomain(MemberPath currentPath)
{
if (_context.ViewTarget == ViewTarget.QueryView && MemberPath.EqualityComparer.Equals(currentPath, _extentPath))
{
IEnumerable types;
if (_typesGenerationMode == ViewGenerationMode.OfTypeOnlyViews)
{
Debug.Assert(!Helper.IsRefType(_generatedType));
HashSet type = new HashSet();
type.Add(_generatedType);
types = type;
}
else
{
types = MetadataHelper.GetTypeAndSubtypesOf(_generatedType, _context.EdmItemCollection, false /* don't include abstract types */);
}
return GetTypeConstants(types);
}
return _domainMap.GetDomain(currentPath);
}
// NULL/default and NOT(...) values in cell constant domains for update views may be unused.
// If we don't detect that and remove them, we can suboptimal (but still correct) update views.
// (For example, SProducts1 in NotNullCorrect.msl has an unused constant NOT("Camera", NULL), which results in a gratuitous join.
// That join could be eliminated due to 1:1 association on C side).
// To determine that a constant is unused, we first try to obtain the S-side rewriting for it.
// If that succeeds, we unfold C-queries, i.e., create OpCellTree for found rewritings,
// and check whether these are unsatisfiable.
// If they indeed are unsatisfiable, we eliminate the constants from the domainMap.
private void AdjustMemberDomainsForUpdateViews()
{
switch (_context.ViewTarget)
{
case ViewTarget.UpdateView:
{
// materialize members in a list so we can modify _domainMap later on
List members = new List(_domainMap.ConditionMembers(_extentPath.Extent));
foreach (MemberPath currentPath in members)
{
// try to remove default value followed by negated value, in this order
IEnumerable oldDomain = _domainMap.GetDomain(currentPath);
Constant defaultValue = oldDomain.FirstOrDefault(domainValue => IsDefaultValue(domainValue, currentPath));
if (defaultValue != null)
{
RemoveUnusedValueFromStoreDomain(defaultValue, currentPath);
}
oldDomain = _domainMap.GetDomain(currentPath); // is case has changed
Constant negatedValue = oldDomain.FirstOrDefault(domainValue => domainValue is NegatedConstant);
if (negatedValue != null)
{
RemoveUnusedValueFromStoreDomain(negatedValue, currentPath);
}
}
break;
}
}
}
private void RemoveUnusedValueFromStoreDomain(Constant domainValue, MemberPath currentPath)
{
// construct WHERE clause for this value
BoolExpression domainWhereClause = CreateMemberCondition(currentPath, domainValue);
// get a rewriting for CASE statements by not requesting any attributes beyond key
Tile caseRewriting;
HashSet outputUsedViews = new HashSet();
bool isUsedValue = false;
if (FindRewritingAndUsedViews(_keyAttributes, domainWhereClause, outputUsedViews, out caseRewriting))
{
// check whether this rewriting is indeed satisfiable using C-side fragment views
// If we wanted to force retention of all negated constants, we could use:
// if (domainValue is NegatedCellConstant) { isUsedValue = true; } else {...}
CellTreeNode cellTree = TileToCellTree((Tile)caseRewriting, _context);
isUsedValue = !cellTree.IsEmptyRightFragmentQuery;
}
if (!isUsedValue)
{
Set newDomain = new Set(_domainMap.GetDomain(currentPath), Constant.EqualityComparer);
newDomain.Remove(domainValue);
TraceVerbose("Shrunk domain of column {0} from {1} to {2}", currentPath, _domainMap.GetDomain(currentPath), newDomain);
_domainMap.UpdateConditionMemberDomain(currentPath, newDomain);
// Update the WHERE clauses of all fragment queries
// Since these are pointers to the respective WHERE clauses in S-side cell queries, those get updated automatically
foreach (FragmentQuery query in _fragmentQueries)
{
query.Condition.FixDomainMap(_domainMap);
}
}
}
// determine the domain query, i.e., the query that returns all keys of the extent to be populated
internal FragmentQuery GetDomainQuery(IEnumerable fragmentQueries, EdmType generatedType)
{
BoolExpression domainQueryCondition = null;
if (_context.ViewTarget == ViewTarget.QueryView)
{
if (generatedType == null)
{
// domainQuery for entire extent: True
domainQueryCondition = BoolExpression.True;
}
else // domainQuery for specific type: WHERE type(path) IS OF (Type)
{
//If Mode is OFTypeOnlyViews then don't get subtypes
IEnumerable derivedTypes;
if (_typesGenerationMode == ViewGenerationMode.OfTypeOnlyViews)
{
Debug.Assert(!Helper.IsRefType(_generatedType));
HashSet type = new HashSet();
type.Add(_generatedType);
derivedTypes = type;
}
else
{
derivedTypes = MetadataHelper.GetTypeAndSubtypesOf(generatedType, _context.EdmItemCollection, false /* don't include abstract types */);
}
Domain typeDomain = new Domain(GetTypeConstants(derivedTypes), _domainMap.GetDomain(_extentPath));
domainQueryCondition = BoolExpression.CreateLiteral(new TypeRestriction(new MemberProjectedSlot(_extentPath), typeDomain), _domainMap);
}
return FragmentQuery.Create(_keyAttributes, domainQueryCondition);
}
else // for update views, domain query = exposed tiles
{
IEnumerable whereClauses = from fragmentQuery in fragmentQueries
select fragmentQuery.Condition;
BoolExpression exposedRegionCondition = BoolExpression.CreateOr(whereClauses.ToArray());
return FragmentQuery.Create(_keyAttributes, exposedRegionCondition);
}
}
// returns true when the case statement is completed
private bool AddRewritingToCaseStatement(Tile rewriting, CaseStatement caseStatement, MemberPath currentPath, Constant domainValue)
{
BoolExpression whenCondition = BoolExpression.True;
// check whether the rewriting is always true or always false
// if it's always true, we don't need any other WHEN clauses in the case statement
// if it's always false, we don't need to add this WHEN clause to the case statement
// given: domainQuery is satisfied. Check (domainQuery -> rewriting)
bool isAlwaysTrue = _qp.IsContainedIn(CreateTile(_domainQuery), rewriting);
bool isAlwaysFalse = _qp.IsDisjointFrom(CreateTile(_domainQuery), rewriting);
Debug.Assert(!(isAlwaysTrue && isAlwaysFalse));
if (isAlwaysFalse)
{
return false; // don't need an unsatisfiable WHEN clause
}
if (isAlwaysTrue)
{
Debug.Assert(caseStatement.Clauses.Count == 0);
}
ProjectedSlot projectedSlot;
if (domainValue.HasNotNull())
{
projectedSlot = new MemberProjectedSlot(currentPath);
}
else
{
projectedSlot = new ConstantProjectedSlot(domainValue);
}
if (!isAlwaysTrue)
{
whenCondition = TileToBoolExpr((Tile)rewriting);
}
else
{
whenCondition = BoolExpression.True;
}
caseStatement.AddWhenThen(whenCondition, projectedSlot);
return isAlwaysTrue;
}
// make sure that we can find a rewriting for each possible entity shape appearing in an extent
// Possible optimization for OfType view generation:
// Cache "used views" for each (currentPath, domainValue) combination
private void EnsureConfigurationIsFullyMapped(MemberPath currentPath,
BoolExpression currentWhereClause,
HashSet outputUsedViews,
ErrorLog errorLog)
{
foreach (Constant domainValue in GetDomain(currentPath))
{
if (domainValue == Constant.Undefined)
{
continue; // no point in trying to recover a situation that can never happen
}
TraceVerbose("REWRITING FOR {0}={1}", currentPath, domainValue);
// construct WHERE clause for this value
BoolExpression domainAddedWhereClause = CreateMemberCondition(currentPath, domainValue);
// AND the current where clause to it
BoolExpression domainWhereClause = BoolExpression.CreateAnd(currentWhereClause, domainAddedWhereClause);
// first check whether we can recover instances of this type - don't care about the attributes - to produce a helpful error message
Tile rewriting;
if (false == FindRewritingAndUsedViews(_keyAttributes, domainWhereClause, outputUsedViews, out rewriting))
{
if (!ErrorPatternMatcher.FindMappingErrors(_context, _domainMap, _errorLog))
{
StringBuilder builder = new StringBuilder();
string extentName = StringUtil.FormatInvariant("{0}", _extentPath);
BoolExpression whereClause = rewriting.Query.Condition;
whereClause.ExpensiveSimplify();
if (whereClause.RepresentsAllTypeConditions)
{
string tableString = Strings.ViewGen_Extent;
builder.AppendLine(Strings.ViewGen_Cannot_Recover_Types_1(tableString, extentName));
}
else
{
string entitiesString = Strings.ViewGen_Entities;
builder.AppendLine(Strings.ViewGen_Cannot_Disambiguate_MultiConstant_2(entitiesString, extentName));
}
RewritingValidator.EntityConfigurationToUserString(whereClause, builder);
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.AmbiguousMultiConstants, builder.ToString(), _context.AllWrappersForExtent, String.Empty);
errorLog.AddEntry(record);
}
}
else
{
TypeConstant typeConstant = domainValue as TypeConstant;
if (typeConstant != null)
{
// we are enumerating types
EdmType edmType = typeConstant.CdmType;
// If can recover the type, make sure can get all the necessary attributes (key is included for EntityTypes)
List nonConditionalAttributes = GetNonConditionalScalarMembers(edmType, currentPath, _domainMap).Union(GetNonConditionalComplexMembers(edmType, currentPath, _domainMap)).ToList();
IEnumerable notCoverdAttributes;
if (nonConditionalAttributes.Count > 0 &&
!FindRewritingAndUsedViews(nonConditionalAttributes, domainWhereClause, outputUsedViews, out rewriting, out notCoverdAttributes))
{
//Error: No mapping specified for some attributes
// remove keys
nonConditionalAttributes = new List(nonConditionalAttributes.Where(a => !a.IsPartOfKey));
Debug.Assert(nonConditionalAttributes.Count > 0, "Must have caught key-only case earlier");
AddUnrecoverableAttributesError(notCoverdAttributes, domainAddedWhereClause, errorLog);
}
else
{
// recurse into complex members
foreach (MemberPath complexMember in GetConditionalComplexMembers(edmType, currentPath, _domainMap))
{
EnsureConfigurationIsFullyMapped(complexMember, domainWhereClause, outputUsedViews, errorLog);
}
// recurse into scalar members
foreach (MemberPath scalarMember in GetConditionalScalarMembers(edmType, currentPath, _domainMap))
{
EnsureConfigurationIsFullyMapped(scalarMember, domainWhereClause, outputUsedViews, errorLog);
}
}
}
}
}
}
private static List GetTypeBasedMemberPathList(IEnumerable nonConditionalScalarAttributes)
{
Debug.Assert(nonConditionalScalarAttributes != null);
List typeBasedMembers = new List();
foreach (MemberPath memberPath in nonConditionalScalarAttributes)
{
EdmMember member = memberPath.LeafEdmMember;
typeBasedMembers.Add(member.DeclaringType.Name + "." + member);
}
return typeBasedMembers;
}
private void AddUnrecoverableAttributesError(IEnumerable attributes, BoolExpression domainAddedWhereClause, ErrorLog errorLog)
{
StringBuilder builder = new StringBuilder();
string extentName = StringUtil.FormatInvariant("{0}", _extentPath);
string tableString = Strings.ViewGen_Extent;
string attributesString = StringUtil.ToCommaSeparatedString(GetTypeBasedMemberPathList(attributes));
builder.AppendLine(Strings.ViewGen_Cannot_Recover_Attributes_2(attributesString, tableString, extentName));
RewritingValidator.EntityConfigurationToUserString(domainAddedWhereClause, builder);
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.AttributesUnrecoverable, builder.ToString(), _context.AllWrappersForExtent, String.Empty);
errorLog.AddEntry(record);
}
private void GenerateCaseStatements(IEnumerable members,
HashSet outputUsedViews)
{
// Compute right domain query - non-simplified version of "basic view"
// It is used below to check whether we need a default value in a case statement
IEnumerable usedCells = _context.AllWrappersForExtent.Where(w => _usedViews.Contains(w.FragmentQuery));
CellTreeNode rightDomainQuery = new OpCellTreeNode(
_context, CellTreeOpType.Union,
usedCells.Select(wrapper => new LeafCellTreeNode(_context, wrapper)).ToArray());
foreach (MemberPath currentPath in members)
{
// Add the types can member have, i.e., its type and its subtypes
List domain = GetDomain(currentPath).ToList();
CaseStatement caseStatement = new CaseStatement(currentPath);
Tile unionCaseRewriting = null;
// optimization for domain = {NULL, NOT_NULL}
// Create a single case: WHEN True THEN currentPath
// Reason: if the WHEN condition is not satisfied (say because of LOJ), then currentPath = NULL
bool needCaseStatement =
!(domain.Count == 2 &&
domain.Contains(Constant.Null, Constant.EqualityComparer) &&
domain.Contains(Constant.NotNull, Constant.EqualityComparer));
{
// go over the domain
foreach (Constant domainValue in domain)
{
if (domainValue == Constant.Undefined && _context.ViewTarget == ViewTarget.QueryView)
{
// we cannot assume closed domain for query views;
// if obtaining undefined is possible, we need to account for that
caseStatement.AddWhenThen(BoolExpression.False /* arbitrary condition */,
new ConstantProjectedSlot(Constant.Undefined));
continue;
}
TraceVerbose("CASE STATEMENT FOR {0}={1}", currentPath, domainValue);
// construct WHERE clause for this value
FragmentQuery memberConditionQuery = CreateMemberConditionQuery(currentPath, domainValue);
Tile caseRewriting;
if (FindRewritingAndUsedViews(memberConditionQuery.Attributes, memberConditionQuery.Condition, outputUsedViews, out caseRewriting))
{
if (_context.ViewTarget == ViewTarget.UpdateView)
{
unionCaseRewriting = (unionCaseRewriting != null) ? _qp.Union(unionCaseRewriting, caseRewriting) : caseRewriting;
}
if (needCaseStatement)
{
bool isAlwaysTrue = AddRewritingToCaseStatement(caseRewriting, caseStatement, currentPath, domainValue);
if (isAlwaysTrue)
{
break;
}
}
}
else
{
if (!IsDefaultValue(domainValue, currentPath))
{
Debug.Assert(_context.ViewTarget == ViewTarget.UpdateView || !_config.IsValidationEnabled);
if (!ErrorPatternMatcher.FindMappingErrors(_context, _domainMap, _errorLog))
{
StringBuilder builder = new StringBuilder();
string extentName = StringUtil.FormatInvariant("{0}", _extentPath);
string objectString = _context.ViewTarget == ViewTarget.QueryView ?
Strings.ViewGen_Entities : Strings.ViewGen_Tuples;
if (_context.ViewTarget == ViewTarget.QueryView)
{
builder.AppendLine(Strings.Viewgen_CannotGenerateQueryViewUnderNoValidation(extentName));
}
else
{
builder.AppendLine(Strings.ViewGen_Cannot_Disambiguate_MultiConstant_2(objectString, extentName));
}
RewritingValidator.EntityConfigurationToUserString(memberConditionQuery.Condition, builder, _context.ViewTarget == ViewTarget.UpdateView);
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.AmbiguousMultiConstants, builder.ToString(), _context.AllWrappersForExtent, String.Empty);
_errorLog.AddEntry(record);
}
}
}
}
}
if (_errorLog.Count == 0)
{
// for update views, add WHEN True THEN defaultValue
// which will ultimately be translated into a (possibly implicit) ELSE clause
if (_context.ViewTarget == ViewTarget.UpdateView && needCaseStatement)
{
AddElseDefaultToCaseStatement(currentPath, caseStatement, domain, rightDomainQuery, unionCaseRewriting);
}
if (caseStatement.Clauses.Count > 0)
{
TraceVerbose("{0}", caseStatement.ToString());
_caseStatements[currentPath] = caseStatement;
}
}
}
}
private void AddElseDefaultToCaseStatement(MemberPath currentPath, CaseStatement caseStatement, List domain,
CellTreeNode rightDomainQuery, Tile unionCaseRewriting)
{
Debug.Assert(_context.ViewTarget == ViewTarget.UpdateView, "Used for update views only");
Constant defaultValue;
bool hasDefaultValue = Domain.TryGetDefaultValueForMemberPath(currentPath, out defaultValue);
if (false == hasDefaultValue || false == domain.Contains(defaultValue))
{
Debug.Assert(unionCaseRewriting != null, "No union of rewritings for case statements");
CellTreeNode unionTree = TileToCellTree(unionCaseRewriting, _context);
FragmentQuery configurationNeedsDefault = _context.RightFragmentQP.Difference(rightDomainQuery.RightFragmentQuery, unionTree.RightFragmentQuery);
if (_context.RightFragmentQP.IsSatisfiable(configurationNeedsDefault))
{
if (hasDefaultValue)
{
caseStatement.AddWhenThen(BoolExpression.True, new ConstantProjectedSlot(defaultValue));
}
else
{
configurationNeedsDefault.Condition.ExpensiveSimplify();
StringBuilder builder = new StringBuilder();
builder.AppendLine(Entity.Strings.ViewGen_No_Default_Value_For_Configuration_0(currentPath.PathToString(false /* for alias */)));
RewritingValidator.EntityConfigurationToUserString(configurationNeedsDefault.Condition, builder);
_errorLog.AddEntry(new ErrorLog.Record(true, ViewGenErrorCode.NoDefaultValue, builder.ToString(), _context.AllWrappersForExtent, String.Empty));
}
}
}
}
// construct top-level WHERE clause
private BoolExpression GetTopLevelWhereClause(HashSet outputUsedViews)
{
BoolExpression topLevelWhereClause = BoolExpression.True;
if (_context.ViewTarget == ViewTarget.QueryView)
{
// check whether a top-level query is needed
if (!_domainQuery.Condition.IsTrue)
{
Tile topLevelRewriting;
if (FindRewritingAndUsedViews(_keyAttributes, _domainQuery.Condition, outputUsedViews, out topLevelRewriting))
{
topLevelWhereClause = TileToBoolExpr(topLevelRewriting);
topLevelWhereClause.ExpensiveSimplify();
}
else
{
Debug.Fail("Can't happen if EnsureExtentIsFullyMapped succeeded");
}
}
}
return topLevelWhereClause;
}
// This makes sure that the mapping describes how to store all C-side data,
// i.e., the view given by C-side cell queries is injective
internal void EnsureExtentIsFullyMapped(HashSet outputUsedViews)
{
if (_context.ViewTarget == ViewTarget.QueryView && _config.IsValidationEnabled)
{
// Run the check below for OfType views too so we can determine
// what views are used (low overhead due to caching of rewritings)
EnsureConfigurationIsFullyMapped(_extentPath, BoolExpression.True, outputUsedViews, _errorLog);
if (_errorLog.Count > 0)
{
ExceptionHelpers.ThrowMappingException(_errorLog, _config);
}
}
else
{
if (_config.IsValidationEnabled)
{
// Ensure that non-nullable, no-default attributes are always populated properly
foreach (MemberPath memberPath in _context.MemberMaps.ProjectedSlotMap.Members)
{
Constant defaultConstant;
if (memberPath.IsScalarType() &&
!memberPath.IsPartOfKey &&
!_domainMap.IsConditionMember(memberPath) &&
!Domain.TryGetDefaultValueForMemberPath(memberPath, out defaultConstant))
{
HashSet attributes = new HashSet(_keyAttributes);
attributes.Add(memberPath);
foreach (LeftCellWrapper leftCellWrapper in _context.AllWrappersForExtent)
{
FragmentQuery fragmentQuery = leftCellWrapper.FragmentQuery;
FragmentQuery tileQuery = new FragmentQuery(fragmentQuery.Description, fragmentQuery.FromVariable,
attributes, fragmentQuery.Condition);
Tile noNullToAvoid = CreateTile(FragmentQuery.Create(_keyAttributes, BoolExpression.CreateNot(fragmentQuery.Condition)));
Tile noNullRewriting;
IEnumerable notCoveredAttributes;
if (!RewriteQuery(CreateTile(tileQuery), noNullToAvoid, /*_views,*/ out noNullRewriting, out notCoveredAttributes, false /* isRelaxed */))
{
// force error
Domain.GetDefaultValueForMemberPath(memberPath, new LeftCellWrapper[] { leftCellWrapper }, _config);
}
}
}
}
}
// find a rewriting for each tile
// some of the views may be redundant and unused
foreach (Tile toFill in _views)
{
Tile rewriting;
Tile toAvoid = CreateTile(FragmentQuery.Create(_keyAttributes, BoolExpression.CreateNot(toFill.Query.Condition)));
IEnumerable notCoveredAttributes;
bool found = RewriteQuery(toFill, toAvoid, out rewriting, out notCoveredAttributes, true /* isRelaxed */);
//Must be able to find the rewriting since the query is one of the views
// otherwise it means condition on the fragment is not satisfiable
if (!found)
{
LeftCellWrapper fragment = _context.AllWrappersForExtent.First(lcr => lcr.FragmentQuery.Equals(toFill.Query));
Debug.Assert(fragment != null);
ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.ImpopssibleCondition, Strings.Viewgen_QV_RewritingNotFound(fragment.RightExtent.ToString()), fragment.Cells, String.Empty);
_errorLog.AddEntry(record);
}
else
{
outputUsedViews.UnionWith(rewriting.GetNamedQueries());
}
}
}
}
// Modifies _caseStatements and _topLevelWhereClause
private List RemapFromVariables()
{
List usedCells = new List();
// remap CellIdBooleans appearing in WHEN clauses and in topLevelWhereClause so the first used cell = 0, second = 1, etc.
// This ordering is exploited in CQL generation
int newNumber = 0;
Dictionary literalRemap = new Dictionary(BoolLiteral.EqualityIdentifierComparer);
foreach (LeftCellWrapper leftCellWrapper in _context.AllWrappersForExtent)
{
if (_usedViews.Contains(leftCellWrapper.FragmentQuery))
{
usedCells.Add(leftCellWrapper);
int oldNumber = leftCellWrapper.OnlyInputCell.CellNumber;
if (newNumber != oldNumber)
{
literalRemap[new CellIdBoolean(_identifiers, oldNumber)] = new CellIdBoolean(_identifiers, newNumber);
}
newNumber++;
}
}
if (literalRemap.Count > 0)
{
// Remap _from literals in WHERE clause
_topLevelWhereClause = _topLevelWhereClause.RemapLiterals(literalRemap);
// Remap _from literals in case statements
Dictionary newCaseStatements = new Dictionary();
foreach (var entry in _caseStatements)
{
CaseStatement newCaseStatement = new CaseStatement(entry.Key);
Debug.Assert(entry.Value.ElseValue == null);
foreach (CaseStatement.WhenThen clause in entry.Value.Clauses)
{
newCaseStatement.AddWhenThen(clause.Condition.RemapLiterals(literalRemap), clause.Value);
}
newCaseStatements[entry.Key] = newCaseStatement;
}
_caseStatements = newCaseStatements;
}
return usedCells;
}
// for backward compatibility: add (WHEN True THEN Type) for non-scalar types
internal void AddTrivialCaseStatementsForConditionMembers()
{
for (int memberNum = 0; memberNum < _context.MemberMaps.ProjectedSlotMap.Count; memberNum++)
{
MemberPath memberPath = _context.MemberMaps.ProjectedSlotMap[memberNum];
if (!memberPath.IsScalarType() && !_caseStatements.ContainsKey(memberPath))
{
Constant typeConstant = new TypeConstant(memberPath.EdmType);
{
CaseStatement caseStmt = new CaseStatement(memberPath);
caseStmt.AddWhenThen(BoolExpression.True, new ConstantProjectedSlot(typeConstant));
_caseStatements[memberPath] = caseStmt;
}
}
}
}
#endregion
#region Computing rewriting
// Find rewriting for query SELECT WHERE FROM _extentPath
// and add view appearing in rewriting to outputUsedViews
private bool FindRewritingAndUsedViews(IEnumerable attributes, BoolExpression whereClause,
HashSet outputUsedViews, out Tile rewriting)
{
IEnumerable notCoveredAttributes;
return FindRewritingAndUsedViews(attributes, whereClause, outputUsedViews, out rewriting,
out notCoveredAttributes);
}
// Find rewriting for query SELECT WHERE FROM _extentPath
// and add view appearing in rewriting to outputUsedViews
private bool FindRewritingAndUsedViews(IEnumerable attributes, BoolExpression whereClause,
HashSet outputUsedViews, out Tile rewriting,
out IEnumerable notCoveredAttributes)
{
if (FindRewriting(attributes, whereClause, out rewriting, out notCoveredAttributes))
{
outputUsedViews.UnionWith(rewriting.GetNamedQueries());
return true;
}
return false;
}
// Find rewriting for query SELECT WHERE FROM _extentPath
private bool FindRewriting(IEnumerable attributes, BoolExpression whereClause,
out Tile rewriting, out IEnumerable notCoveredAttributes)
{
Tile toFill = CreateTile(FragmentQuery.Create(attributes, whereClause));
Debug.Assert(toFill.Query.Attributes.Count > 0, "Query has no attributes?");
Tile toAvoid = CreateTile(FragmentQuery.Create(_keyAttributes, BoolExpression.CreateNot(whereClause)));
bool isRelaxed = (_context.ViewTarget == ViewTarget.UpdateView);
bool found = RewriteQuery(toFill, toAvoid, out rewriting, out notCoveredAttributes, isRelaxed);
Debug.Assert(!found || rewriting.GetNamedQueries().All(q => q != TrueViewSurrogate.Query),
"TrueViewSurrogate should have been substituted");
return found;
}
private bool RewriteQuery(Tile toFill, Tile toAvoid, out Tile rewriting, out IEnumerable notCoveredAttributes,
bool isRelaxed)
{
notCoveredAttributes = new List();
// first, find a rewriting for WHERE clause only
FragmentQuery toFillQuery = toFill.Query;
if (_context.TryGetCachedRewriting(toFillQuery, out rewriting))
{
TraceVerbose("Cached rewriting {0}: {1}", toFill, rewriting);
return true; // query with attributes is already cached
}
// Filter the relevant views. These may include a TrueSurrogate view
IEnumerable> relevantViews = GetRelevantViews(toFillQuery, isRelaxed);
FragmentQuery originalToFillQuery = toFillQuery;
if (!RewriteQueryCached(CreateTile(FragmentQuery.Create(toFillQuery.Condition)), toAvoid, relevantViews, out rewriting))
{
if (isRelaxed)
{
// don't give up quite yet
toFillQuery = FragmentQuery.Create(toFillQuery.Attributes, BoolExpression.CreateAndNot(toFillQuery.Condition, rewriting.Query.Condition));
if (_qp.IsEmpty(CreateTile(toFillQuery)) ||
!RewriteQueryCached(CreateTile(FragmentQuery.Create(toFillQuery.Condition)), toAvoid, relevantViews, out rewriting))
{
return false; // finally give up
}
}
else
{
return false;
}
}
if (toFillQuery.Attributes.Count == 0)
{
// return w/o trying to remove TrueSurrogate from view - it's an attribute-less view
// we keep TrueSurrogate there because it may be expanded in various ways for
// different projected attributes
return true;
}
// now we have the rewriting for WHERE
Dictionary attributeConditions = new Dictionary();
foreach (MemberPath attribute in NonKeys(toFillQuery.Attributes))
{
attributeConditions[attribute] = toFillQuery;
}
if (attributeConditions.Count == 0 || CoverAttributes(ref rewriting, toFillQuery, attributeConditions))
{
GetUsedViewsAndRemoveTrueSurrogate(ref rewriting);
_context.SetCachedRewriting(originalToFillQuery, rewriting);
return true; // all attributes are covered
}
else if (isRelaxed)
{
// re-initialize attributeConditions by subtracting the remaining attributes to cover
foreach (MemberPath attribute in NonKeys(toFillQuery.Attributes))
{
FragmentQuery remainingCondition;
if (attributeConditions.TryGetValue(attribute, out remainingCondition))
{
attributeConditions[attribute] = FragmentQuery.Create(BoolExpression.CreateAndNot(toFillQuery.Condition, remainingCondition.Condition));
}
else
{
attributeConditions[attribute] = toFillQuery;
}
}
if (CoverAttributes(ref rewriting, toFillQuery, attributeConditions))
{
GetUsedViewsAndRemoveTrueSurrogate(ref rewriting);
_context.SetCachedRewriting(originalToFillQuery, rewriting);
return true;
}
}
notCoveredAttributes = attributeConditions.Keys;
return false;
}
// input views may contain TrueSurrogate
private bool RewriteQueryCached(Tile toFill, Tile toAvoid,
IEnumerable> views, out Tile rewriting)
{
Debug.Assert(toFill.Query.Attributes.Count == 0, "This method is used for attribute-less queries only");
if (!_context.TryGetCachedRewriting(toFill.Query, out rewriting))
{
bool hasRewriting = _qp.RewriteQuery(toFill, toAvoid, views, out rewriting);
TraceVerbose("Computed rewriting {0}: {1}", toFill, rewriting);
if (hasRewriting)
{
_context.SetCachedRewriting(toFill.Query, rewriting);
}
return hasRewriting;
}
TraceVerbose("Cached rewriting {0}: {1}", toFill, rewriting);
return true;
}
private bool CoverAttributes(ref Tile rewriting, FragmentQuery toFillQuery,
Dictionary attributeConditions)
{
// first, account for already used views
HashSet usedViews = new HashSet(rewriting.GetNamedQueries());
Debug.Assert(usedViews.Count > 0);
//List usedViewsList = new List(usedViews);
//usedViewsList.Sort(FragmentQuery.GetComparer(toFillQuery.Attributes));
foreach (FragmentQuery view in usedViews)
{
foreach (MemberPath projectedAttribute in NonKeys(view.Attributes))
{
CoverAttribute(projectedAttribute, view, attributeConditions, toFillQuery);
}
if (attributeConditions.Count == 0)
{
return true; // we are done
}
}
// still need to fill some attributes
Tile attributeTile = null;
foreach (FragmentQuery view in _fragmentQueries)
{
foreach (MemberPath projectedAttribute in NonKeys(view.Attributes))
{
if (CoverAttribute(projectedAttribute, view, attributeConditions, toFillQuery))
{
attributeTile = (attributeTile == null) ? CreateTile(view) : _qp.Union(attributeTile, CreateTile(view));
}
}
if (attributeConditions.Count == 0)
{
break; // we are done!
}
}
if (attributeConditions.Count == 0)
{
// yes, we covered all attributes
Debug.Assert(attributeTile != null);
rewriting = _qp.Join(rewriting, attributeTile);
return true;
}
else
{
// create rewriting that we couldn't satisfy
return false; // couldn't cover some attribute(s)
}
}
// returns true if the view is useful for covering the projected attribute
private bool CoverAttribute(MemberPath projectedAttribute, FragmentQuery view, Dictionary attributeConditions, FragmentQuery toFillQuery)
{
FragmentQuery currentAttributeCondition;
if (attributeConditions.TryGetValue(projectedAttribute, out currentAttributeCondition))
{
currentAttributeCondition = FragmentQuery.Create(BoolExpression.CreateAndNot(currentAttributeCondition.Condition, view.Condition));
if (_qp.IsEmpty(CreateTile(currentAttributeCondition)))
{
// this attribute is covered! remove it from the list
attributeConditions.Remove(projectedAttribute);
}
else
{
attributeConditions[projectedAttribute] = currentAttributeCondition;
}
return true;
}
return false;
}
private IEnumerable> GetRelevantViews(FragmentQuery query, bool isRelaxed)
{
// Step 1:
// Determine connected and directly/indirectly connected variables
// Directly connected variables: those that appear in query's WHERE clause
// Indirectly connected variables: directly connected variables + variables in all views that contain directly connected variables
// Disconnected variables: those that appear in some view's WHERE clause but are not indirectly connected
Set connectedVariables = GetVariables(query);
// Step 2:
// Take a union of all views that contain connected variables
// If it evaluates to True, we can discard all other views; no special True-view is needed
// Otherwise:
// If isRelaxed == false:
// Take a union of all views. If it yields True, than assume that True-view is available.
// Later, try to pick a smaller subset (instead of all views) once we know that attributes are needed
// If isRelaxed == true:
// Discard all views that don't contain connected variables; assume that True-view is available
Tile unionOfConnectedViews = null;
List> connectedViews = new List>();
Tile firstTrueView = null;
foreach (Tile tile in _views)
{
// notice: this is a syntactic check. We assume that if the variable is not present in the condition,
// its value is unrestricted (which in general may not be true because the KB may have e.g., X=1 => Y=1,
// so even if condition on Y is absent, the view would still be relevant
if (GetVariables(tile.Query).Overlaps(connectedVariables))
{
unionOfConnectedViews = (unionOfConnectedViews == null) ? tile : _qp.Union(unionOfConnectedViews, tile);
connectedViews.Add(tile);
}
else if (IsTrue(tile.Query) && firstTrueView == null)
{
firstTrueView = tile; // don't add True views; only one of them might be needed, if at all
}
}
if (unionOfConnectedViews != null &&
IsTrue(unionOfConnectedViews.Query)) // the collected views give us "True"
{
return connectedViews;
}
if (firstTrueView == null)
{
// can we obtain True at all?
Tile unionTile = null;
foreach (FragmentQuery view in _fragmentQueries)
{
unionTile = (unionTile == null) ? CreateTile(view) : _qp.Union(unionTile, CreateTile(view));
if (IsTrue(unionTile.Query))
{
// yes, we can; use a surrogate view - replace it later
firstTrueView = TrueViewSurrogate;
break;
}
}
}
if (firstTrueView != null) // the collected views don't give us True, but
{
connectedViews.Add(firstTrueView);
return connectedViews;
}
// Step 3:
// For each indirectly-connected variable x:
// Union all views that contain x. The condition on x must disappear, i.e., union must imply that x is in Domain(x)
// That is, the union must be equivalent to the expression in which all conditions on x have been eliminated.
// If that's not the case (i.e., can't get rid of x), remove all these views from consideration.
return _views;
}
private HashSet GetUsedViewsAndRemoveTrueSurrogate(ref Tile rewriting)
{
HashSet usedViews = new HashSet(rewriting.GetNamedQueries());
if (!usedViews.Contains(TrueViewSurrogate.Query))
{
return usedViews; // no surrogate
}
// remove the surrogate
usedViews.Remove(TrueViewSurrogate.Query);
// first, try to union usedViews to see whether we can get True
Tile unionTile = null;
IEnumerable usedFollowedByUnusedViews = usedViews.Concat(_fragmentQueries);
foreach (FragmentQuery view in usedFollowedByUnusedViews)
{
unionTile = (unionTile == null) ? CreateTile(view) : _qp.Union(unionTile, CreateTile(view));
usedViews.Add(view);
if (IsTrue(unionTile.Query))
{
// we found a true rewriting
rewriting = rewriting.Replace(TrueViewSurrogate, unionTile);
return usedViews;
}
}
// now we either found the rewriting or we can just take all views because we are in relaxed mode for update views
Debug.Fail("Shouldn't happen");
return usedViews;
}
#endregion
#region Helper methods
private BoolExpression CreateMemberCondition(MemberPath path, Constant domainValue)
{
return FragmentQuery.CreateMemberCondition(path, domainValue, _domainMap);
}
private FragmentQuery CreateMemberConditionQuery(MemberPath currentPath, Constant domainValue)
{
return CreateMemberConditionQuery(currentPath, domainValue, _keyAttributes, _domainMap);
}
internal static FragmentQuery CreateMemberConditionQuery(MemberPath currentPath, Constant domainValue,
IEnumerable keyAttributes, MemberDomainMap domainMap)
{
// construct WHERE clause for this value
BoolExpression domainWhereClause = FragmentQuery.CreateMemberCondition(currentPath, domainValue, domainMap);
// get a rewriting for CASE statements by not requesting any attributes beyond key
IEnumerable attributes = keyAttributes;
if (domainValue is NegatedConstant)
{
// we need the attribute value
attributes = keyAttributes.Concat(new MemberPath[] { currentPath });
}
return FragmentQuery.Create(attributes, domainWhereClause);
}
private static TileNamed CreateTile(FragmentQuery query)
{
return new TileNamed(query);
}
private static IEnumerable GetTypeConstants(IEnumerable types)
{
foreach (EdmType type in types)
{
yield return new TypeConstant(type);
}
}
private static IEnumerable GetNonConditionalScalarMembers(EdmType edmType, MemberPath currentPath, MemberDomainMap domainMap)
{
return currentPath.GetMembers(edmType, true /* isScalar */, false /* isConditional */, null /* isPartOfKey */, domainMap);
}
private static IEnumerable GetConditionalComplexMembers(EdmType edmType, MemberPath currentPath, MemberDomainMap domainMap)
{
return currentPath.GetMembers(edmType, false /* isScalar */, true /* isConditional */, null /* isPartOfKey */, domainMap);
}
private static IEnumerable GetNonConditionalComplexMembers(EdmType edmType, MemberPath currentPath, MemberDomainMap domainMap)
{
return currentPath.GetMembers(edmType, false /* isScalar */, false /* isConditional */, null /* isPartOfKey */, domainMap);
}
private static IEnumerable GetConditionalScalarMembers(EdmType edmType, MemberPath currentPath, MemberDomainMap domainMap)
{
return currentPath.GetMembers(edmType, true /* isScalar */, true /* isConditional */, null /* isPartOfKey */, domainMap);
}
private IEnumerable NonKeys(IEnumerable attributes)
{
return attributes.Where(attr => !attr.IsPartOfKey);
}
// allows us to check whether a found rewriting is satisfiable
// by taking into account the "other side" of mapping constraints
// (Ultimately, should produce a CQT and use general-purpose query containment)
internal static CellTreeNode TileToCellTree(Tile tile, ViewgenContext context)
{
if (tile.OpKind == TileOpKind.Named)
{
FragmentQuery view = ((TileNamed)tile).NamedQuery;
LeftCellWrapper leftCellWrapper = context.AllWrappersForExtent.First(w => w.FragmentQuery == view);
return new LeafCellTreeNode(context, leftCellWrapper);
}
CellTreeOpType opType;
switch (tile.OpKind)
{
case TileOpKind.Join: opType = CellTreeOpType.IJ; break;
case TileOpKind.AntiSemiJoin: opType = CellTreeOpType.LASJ; break;
case TileOpKind.Union: opType = CellTreeOpType.Union; break;
default:
Debug.Fail("unexpected");
return null;
}
return new OpCellTreeNode(context, opType,
TileToCellTree(tile.Arg1, context),
TileToCellTree(tile.Arg2, context));
}
private static BoolExpression TileToBoolExpr(Tile tile)
{
switch (tile.OpKind)
{
case TileOpKind.Named:
FragmentQuery view = ((TileNamed)tile).NamedQuery;
if (view.Condition.IsAlwaysTrue())
{
return BoolExpression.True;
}
else
{
Debug.Assert(view.FromVariable != null);
return view.FromVariable;
}
case TileOpKind.Join:
return BoolExpression.CreateAnd(TileToBoolExpr(tile.Arg1), TileToBoolExpr(tile.Arg2));
case TileOpKind.AntiSemiJoin:
return BoolExpression.CreateAnd(TileToBoolExpr(tile.Arg1), BoolExpression.CreateNot(TileToBoolExpr(tile.Arg2)));
case TileOpKind.Union:
return BoolExpression.CreateOr(TileToBoolExpr(tile.Arg1), TileToBoolExpr(tile.Arg2));
default:
Debug.Fail("unexpected");
return null;
}
}
private static bool IsDefaultValue(Constant domainValue, MemberPath path)
{
if (domainValue.IsNull() && path.IsNullable)
{
return true;
}
if (path.DefaultValue != null)
{
ScalarConstant scalarConstant = domainValue as ScalarConstant;
return scalarConstant.Value == path.DefaultValue;
}
return false;
}
// Returns MemberPaths which have conditions in the where clause
// Filters out all trivial conditions (e.g., num=1 where dom(num)={1})
// i.e., where all constants from the domain are contained in range
private Set GetVariables(FragmentQuery query)
{
IEnumerable memberVariables =
from domainConstraint in query.Condition.VariableConstraints
where domainConstraint.Variable.Identifier is MemberRestriction &&
false == domainConstraint.Variable.Domain.All(constant => domainConstraint.Range.Contains(constant))
select ((MemberRestriction)domainConstraint.Variable.Identifier).RestrictedMemberSlot.MemberPath;
return new Set(memberVariables, MemberPath.EqualityComparer);
}
private bool IsTrue(FragmentQuery query)
{
return !_context.LeftFragmentQP.IsSatisfiable(FragmentQuery.Create(BoolExpression.CreateNot(query.Condition)));
}
[Conditional("DEBUG")]
private void PrintStatistics(RewritingProcessor> qp)
{
int numSATChecks;
int numIntersection;
int numDifference;
int numUnion;
int numErrors;
qp.GetStatistics(out numSATChecks, out numIntersection, out numUnion, out numDifference, out numErrors);
TraceVerbose("{0} containment checks, {4} set operations ({1} intersections + {2} unions + {3} differences)",
numSATChecks, numIntersection, numUnion, numDifference,
numIntersection + numUnion + numDifference);
TraceVerbose("{0} errors", numErrors);
}
[Conditional("DEBUG")]
internal void TraceVerbose(string msg, params object[] parameters)
{
if (_config.IsVerboseTracing)
{
Helpers.FormatTraceLine(msg, parameters);
}
}
#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
- HttpBrowserCapabilitiesBase.cs
- BlurEffect.cs
- BinaryObjectWriter.cs
- HttpBindingExtension.cs
- XmlConvert.cs
- DataServiceQueryException.cs
- SimplePropertyEntry.cs
- FontStyles.cs
- ReadOnlyKeyedCollection.cs
- DataGridState.cs
- DBSchemaTable.cs
- ControlBuilderAttribute.cs
- NativeMethods.cs
- InheritanceAttribute.cs
- NavigationFailedEventArgs.cs
- DataSourceProvider.cs
- NavigateEvent.cs
- SerializationUtilities.cs
- Model3D.cs
- TemplateBindingExpression.cs
- BaseUriHelper.cs
- ColorTransformHelper.cs
- MessageQueue.cs
- TypeDependencyAttribute.cs
- SqlServices.cs
- WasAdminWrapper.cs
- CodeNamespaceCollection.cs
- documentsequencetextpointer.cs
- IPeerNeighbor.cs
- ContentOperations.cs
- HwndTarget.cs
- RandomNumberGenerator.cs
- X509AsymmetricSecurityKey.cs
- ImageSourceValueSerializer.cs
- DrawingCollection.cs
- XhtmlBasicPageAdapter.cs
- PerfService.cs
- TriggerBase.cs
- FontInfo.cs
- NativeMethods.cs
- WSUtilitySpecificationVersion.cs
- DocComment.cs
- HttpContext.cs
- GraphicsState.cs
- TreeNodeStyle.cs
- SqlDataSourceCustomCommandEditor.cs
- StoragePropertyMapping.cs
- Registry.cs
- MergablePropertyAttribute.cs
- Fault.cs
- Journal.cs
- fixedPageContentExtractor.cs
- DragEventArgs.cs
- HttpHandlersSection.cs
- SystemResources.cs
- returneventsaver.cs
- RestrictedTransactionalPackage.cs
- XDeferredAxisSource.cs
- HuffCodec.cs
- CodeMemberProperty.cs
- FormsAuthenticationEventArgs.cs
- WaitHandleCannotBeOpenedException.cs
- ErrorWebPart.cs
- KeyedHashAlgorithm.cs
- AmbientValueAttribute.cs
- SqlMethods.cs
- NullRuntimeConfig.cs
- XmlCustomFormatter.cs
- X509CertificateChain.cs
- shaperfactory.cs
- DiscoveryClientElement.cs
- RadioButtonStandardAdapter.cs
- PageContentAsyncResult.cs
- AddInProcess.cs
- GeneralTransform3DTo2DTo3D.cs
- HttpSocketManager.cs
- ExpressionConverter.cs
- Source.cs
- WebBrowserUriTypeConverter.cs
- VisualTransition.cs
- CompilerGlobalScopeAttribute.cs
- SolidColorBrush.cs
- FolderNameEditor.cs
- Message.cs
- TableDetailsRow.cs
- TextCharacters.cs
- Trace.cs
- dbdatarecord.cs
- PagedDataSource.cs
- MarshalByRefObject.cs
- PartDesigner.cs
- QueryPageSettingsEventArgs.cs
- ComponentChangingEvent.cs
- FloatSumAggregationOperator.cs
- ExceptQueryOperator.cs
- OleDbConnectionFactory.cs
- CacheEntry.cs
- DbConnectionStringCommon.cs
- DispatchChannelSink.cs
- EncoderParameters.cs