Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / ndp / fx / src / DataEntity / System / Data / Query / InternalTrees / RelOps.cs / 2 / RelOps.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Data.Metadata.Edm;
using System.Diagnostics;
using System.Globalization;
using System.Text;
namespace System.Data.Query.InternalTrees
{
internal abstract class ScanTableBaseOp : RelOp
{
#region private state
private Table m_table;
#endregion
#region constructors
protected ScanTableBaseOp(OpType opType, Table table)
: base(opType)
{
m_table = table;
}
protected ScanTableBaseOp(OpType opType)
: base(opType)
{ }
#endregion
#region public methods
///
/// Get the table instance produced by this Op
///
internal Table Table { get { return m_table; } }
#endregion
}
///
/// Scans a table
///
internal sealed class ScanTableOp : ScanTableBaseOp
{
#region constructors
///
/// Scan constructor
///
///
internal ScanTableOp(Table table)
: base(OpType.ScanTable, table)
{
}
private ScanTableOp() : base(OpType.ScanTable) { }
#endregion
#region public methods
///
/// Only to be used for pattern matches
///
internal static readonly ScanTableOp Pattern = new ScanTableOp();
///
/// No children
///
internal override int Arity {get {return 0;} }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Scans a view - very similar to a ScanTable
///
internal sealed class ScanViewOp : ScanTableBaseOp
{
#region constructors
///
/// Scan constructor
///
///
internal ScanViewOp(Table table)
: base(OpType.ScanView, table)
{
}
private ScanViewOp() : base(OpType.ScanView) { }
#endregion
#region public methods
///
/// Only to be used for pattern matches
///
internal static readonly ScanViewOp Pattern = new ScanViewOp();
///
/// Exactly 1 child
///
internal override int Arity { get { return 1; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Scans a virtual extent (ie) a transient collection
///
internal sealed class UnnestOp : RelOp
{
#region private state
private Table m_table;
private Var m_var;
#endregion
#region constructors
internal UnnestOp(Var v, Table t) : this()
{
m_var = v;
m_table = t;
}
private UnnestOp()
: base(OpType.Unnest)
{
}
#endregion
#region publics
internal static readonly UnnestOp Pattern = new UnnestOp();
///
/// The (collection-typed) Var that's being unnested
///
internal Var Var { get { return m_var; } }
///
/// The table instance produced by this Op
///
internal Table Table { get { return m_table; } }
///
/// Exactly 1 child
///
internal override int Arity { get { return 1; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Base class for all Join operations
///
internal abstract class JoinBaseOp : RelOp
{
#region constructors
internal JoinBaseOp(OpType opType) : base(opType) { }
#endregion
#region public surface
///
/// 3 children - left, right, pred
///
internal override int Arity { get { return 3; } }
#endregion
}
///
/// A CrossJoin (n-way)
///
internal sealed class CrossJoinOp : JoinBaseOp
{
#region constructors
private CrossJoinOp() : base(OpType.CrossJoin) { }
#endregion
#region public methods
///
/// Singleton instance
///
internal static readonly CrossJoinOp Instance = new CrossJoinOp();
internal static readonly CrossJoinOp Pattern = CrossJoinOp.Instance;
///
/// varying number of children (but usually greater than 1)
///
internal override int Arity { get { return ArityVarying; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// An InnerJoin
///
internal sealed class InnerJoinOp : JoinBaseOp
{
#region constructors
private InnerJoinOp() : base(OpType.InnerJoin) { }
#endregion
#region public methods
internal static readonly InnerJoinOp Instance = new InnerJoinOp();
internal static readonly InnerJoinOp Pattern = InnerJoinOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// A LeftOuterJoin
///
internal sealed class LeftOuterJoinOp : JoinBaseOp
{
#region constructors
private LeftOuterJoinOp() : base(OpType.LeftOuterJoin) { }
#endregion
#region public methods
internal static readonly LeftOuterJoinOp Instance = new LeftOuterJoinOp();
internal static readonly LeftOuterJoinOp Pattern = LeftOuterJoinOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// A FullOuterJoin
///
internal sealed class FullOuterJoinOp : JoinBaseOp
{
#region private constructors
private FullOuterJoinOp() : base(OpType.FullOuterJoin) { }
#endregion
#region public methods
internal static readonly FullOuterJoinOp Instance = new FullOuterJoinOp();
internal static readonly FullOuterJoinOp Pattern = FullOuterJoinOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Base class for all Apply Ops
///
internal abstract class ApplyBaseOp : RelOp
{
#region constructors
internal ApplyBaseOp(OpType opType) : base(opType) { }
#endregion
#region public surface
///
/// 2 children - left, right
///
internal override int Arity { get { return 2; } }
#endregion
}
///
/// CrossApply
///
internal sealed class CrossApplyOp : ApplyBaseOp
{
#region constructors
private CrossApplyOp() : base(OpType.CrossApply) { }
#endregion
#region public methods
internal static readonly CrossApplyOp Instance = new CrossApplyOp();
internal static readonly CrossApplyOp Pattern = CrossApplyOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// OuterApply
///
internal sealed class OuterApplyOp : ApplyBaseOp
{
#region constructors
private OuterApplyOp() : base(OpType.OuterApply) { }
#endregion
#region public methods
internal static readonly OuterApplyOp Instance = new OuterApplyOp();
internal static readonly OuterApplyOp Pattern = OuterApplyOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// FilterOp
///
internal sealed class FilterOp : RelOp
{
#region constructors
private FilterOp() : base(OpType.Filter) { }
#endregion
#region public methods
internal static readonly FilterOp Instance = new FilterOp();
internal static readonly FilterOp Pattern = FilterOp.Instance;
///
/// 2 children - input, pred
///
internal override int Arity { get { return 2; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// ProjectOp
///
internal sealed class ProjectOp : RelOp
{
#region private state
private VarVec m_vars;
#endregion
#region constructors
private ProjectOp()
: base(OpType.Project)
{ }
internal ProjectOp(VarVec vars) : this()
{
Debug.Assert(null != vars, "null vars?");
Debug.Assert(!vars.IsEmpty, "empty varlist?");
m_vars = vars;
}
#endregion
#region public methods
internal static readonly ProjectOp Pattern = new ProjectOp();
///
/// 2 children - input, projections (VarDefList)
///
internal override int Arity { get { return 2; } }
///
/// The Vars projected by this Op
///
internal VarVec Outputs { get { return m_vars; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// A Sortkey
///
internal class SortKey
{
#region private state
private Var m_var;
private bool m_asc;
private string m_collation;
#endregion
#region constructors
internal SortKey(Var v, bool asc, string collation)
{
m_var = v;
m_asc = asc;
m_collation = collation;
}
#endregion
#region public methods
///
/// The Var being sorted
///
internal Var Var
{
get { return m_var; }
set { m_var = value; }
}
///
/// Is this a sort asc, or a sort desc
///
internal bool AscendingSort { get { return m_asc; } }
///
/// An optional collation (only for string types)
///
internal string Collation { get { return m_collation; } }
#endregion
}
///
/// Base type for SortOp and ConstrainedSortOp
///
internal abstract class SortBaseOp : RelOp
{
#region private state
private List m_keys;
#endregion
#region Constructors
// Pattern constructor
internal SortBaseOp(OpType opType)
: base(opType)
{
Debug.Assert(opType == OpType.Sort || opType == OpType.ConstrainedSort, "SortBaseOp OpType must be Sort or ConstrainedSort");
}
internal SortBaseOp(OpType opType, List sortKeys)
: this(opType)
{
m_keys = sortKeys;
}
#endregion
///
/// Sort keys
///
internal List Keys { get { return m_keys; } }
}
///
/// A SortOp
///
internal sealed class SortOp : SortBaseOp
{
#region constructors
private SortOp() : base(OpType.Sort) { }
internal SortOp(List sortKeys) : base(OpType.Sort, sortKeys) {}
#endregion
#region public methods
internal static readonly SortOp Pattern = new SortOp();
///
/// 1 child - the input, SortOp must not contain local VarDefs
///
internal override int Arity { get { return 1; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// A Constrained SortOp. Used to represent physical paging (skip, limit, skip + limit) operations.
///
internal sealed class ConstrainedSortOp : SortBaseOp
{
#region private state
private bool _withTies;
#endregion
#region constructors
// Pattern constructor
private ConstrainedSortOp() : base(OpType.ConstrainedSort) { }
internal ConstrainedSortOp(List sortKeys, bool withTies)
: base(OpType.ConstrainedSort, sortKeys)
{
_withTies = withTies;
}
#endregion
#region public methods
internal bool WithTies { get { return _withTies; } set { _withTies = value; } }
internal static readonly ConstrainedSortOp Pattern = new ConstrainedSortOp();
///
/// 3 children - the input, a possibly NullOp limit and a possibly NullOp skip count.
///
internal override int Arity { get { return 3; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// GroupByOp
///
internal sealed class GroupByOp : RelOp
{
#region private state
private VarVec m_keys;
private VarVec m_outputs;
#endregion
#region constructors
private GroupByOp() : base(OpType.GroupBy) { }
internal GroupByOp(VarVec keys, VarVec outputs)
: this()
{
m_keys = keys;
m_outputs = outputs;
}
#endregion
#region public methods
internal static readonly GroupByOp Pattern = new GroupByOp();
///
/// 3 children - input, keys (vardeflist), aggregates (vardeflist)
///
internal override int Arity { get { return 3; } }
///
/// GroupBy keys
///
internal VarVec Keys { get { return m_keys; } }
///
/// All outputs of this Op - includes keys and aggregates
///
internal VarVec Outputs { get { return m_outputs; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Base class for set operations - union, intersect, except
///
internal abstract class SetOp : RelOp
{
#region private state
private VarMap[] m_varMap;
private VarVec m_outputVars;
#endregion
#region constructors
internal SetOp(OpType opType, VarVec outputs, VarMap left, VarMap right)
: this(opType)
{
m_varMap = new VarMap[2];
m_varMap[0] = left;
m_varMap[1] = right;
m_outputVars = outputs;
}
protected SetOp(OpType opType) : base(opType)
{
}
#endregion
#region public methods
///
/// 2 children - left, right
///
internal override int Arity { get { return 2; } }
///
/// Map of result vars to the vars of each branch of the setOp
///
internal VarMap[] VarMap { get { return m_varMap; } }
///
/// Get the set of output vars produced
///
internal VarVec Outputs { get { return m_outputVars; } }
#endregion
}
///
/// UnionAll (ie) no duplicate elimination
///
internal sealed class UnionAllOp : SetOp
{
#region private state
private Var m_branchDiscriminator;
#endregion
#region constructors
private UnionAllOp() : base(OpType.UnionAll) { }
internal UnionAllOp(VarVec outputs, VarMap left, VarMap right, Var branchDiscriminator) : base(OpType.UnionAll, outputs, left, right)
{
m_branchDiscriminator = branchDiscriminator;
}
#endregion
#region public methods
internal static readonly UnionAllOp Pattern = new UnionAllOp();
///
/// Returns the branch discriminator var for this op. It may be null, if
/// we haven't been through key pullup yet.
///
internal Var BranchDiscriminator { get { return m_branchDiscriminator; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// An IntersectOp
///
internal sealed class IntersectOp : SetOp
{
#region constructors
private IntersectOp() : base(OpType.Intersect) { }
internal IntersectOp(VarVec outputs, VarMap left, VarMap right) : base(OpType.Intersect, outputs, left,right) { }
#endregion
#region public methods
internal static readonly IntersectOp Pattern = new IntersectOp();
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// ExceptOp (Minus)
///
internal sealed class ExceptOp : SetOp
{
#region constructors
private ExceptOp() : base(OpType.Except) { }
internal ExceptOp(VarVec outputs, VarMap left, VarMap right) : base(OpType.Except, outputs, left, right) { }
#endregion
#region public methods
internal static readonly ExceptOp Pattern = new ExceptOp();
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// DistinctOp
///
internal sealed class DistinctOp : RelOp
{
#region private state
private VarVec m_keys;
#endregion
#region constructors
private DistinctOp() : base(OpType.Distinct)
{
}
internal DistinctOp(VarVec keyVars) : this()
{
Debug.Assert(keyVars != null);
Debug.Assert(!keyVars.IsEmpty);
m_keys = keyVars;
}
#endregion
#region public methods
internal static readonly DistinctOp Pattern = new DistinctOp();
///
/// 1 child - input
///
internal override int Arity { get { return 1; } }
///
/// Get "key" vars for the distinct
///
internal VarVec Keys { get { return m_keys; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Selects out a single row from a underlying subquery. Two flavors of this Op exist.
/// The first flavor enforces the single-row-ness (ie) an error is raised if the
/// underlying subquery produces more than one row.
/// The other flavor simply choses any row from the input
///
internal sealed class SingleRowOp : RelOp
{
#region constructors
private SingleRowOp() : base(OpType.SingleRow) { }
#endregion
#region public methods
///
/// Singleton instance
///
internal static readonly SingleRowOp Instance = new SingleRowOp();
///
/// Pattern for transformation rules
///
internal static readonly SingleRowOp Pattern = Instance;
///
/// 1 child - input
///
internal override int Arity { get { return 1; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Represents a table with a single row
///
internal sealed class SingleRowTableOp : RelOp
{
#region constructors
private SingleRowTableOp() : base(OpType.SingleRowTable) { }
#endregion
#region public methods
///
/// Singleton instance
///
internal static readonly SingleRowTableOp Instance = new SingleRowTableOp();
///
/// Pattern for transformation rules
///
internal static readonly SingleRowTableOp Pattern = Instance;
///
/// 0 children
///
internal override int Arity { get { return 0; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Data.Metadata.Edm;
using System.Diagnostics;
using System.Globalization;
using System.Text;
namespace System.Data.Query.InternalTrees
{
internal abstract class ScanTableBaseOp : RelOp
{
#region private state
private Table m_table;
#endregion
#region constructors
protected ScanTableBaseOp(OpType opType, Table table)
: base(opType)
{
m_table = table;
}
protected ScanTableBaseOp(OpType opType)
: base(opType)
{ }
#endregion
#region public methods
///
/// Get the table instance produced by this Op
///
internal Table Table { get { return m_table; } }
#endregion
}
///
/// Scans a table
///
internal sealed class ScanTableOp : ScanTableBaseOp
{
#region constructors
///
/// Scan constructor
///
///
internal ScanTableOp(Table table)
: base(OpType.ScanTable, table)
{
}
private ScanTableOp() : base(OpType.ScanTable) { }
#endregion
#region public methods
///
/// Only to be used for pattern matches
///
internal static readonly ScanTableOp Pattern = new ScanTableOp();
///
/// No children
///
internal override int Arity {get {return 0;} }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Scans a view - very similar to a ScanTable
///
internal sealed class ScanViewOp : ScanTableBaseOp
{
#region constructors
///
/// Scan constructor
///
///
internal ScanViewOp(Table table)
: base(OpType.ScanView, table)
{
}
private ScanViewOp() : base(OpType.ScanView) { }
#endregion
#region public methods
///
/// Only to be used for pattern matches
///
internal static readonly ScanViewOp Pattern = new ScanViewOp();
///
/// Exactly 1 child
///
internal override int Arity { get { return 1; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Scans a virtual extent (ie) a transient collection
///
internal sealed class UnnestOp : RelOp
{
#region private state
private Table m_table;
private Var m_var;
#endregion
#region constructors
internal UnnestOp(Var v, Table t) : this()
{
m_var = v;
m_table = t;
}
private UnnestOp()
: base(OpType.Unnest)
{
}
#endregion
#region publics
internal static readonly UnnestOp Pattern = new UnnestOp();
///
/// The (collection-typed) Var that's being unnested
///
internal Var Var { get { return m_var; } }
///
/// The table instance produced by this Op
///
internal Table Table { get { return m_table; } }
///
/// Exactly 1 child
///
internal override int Arity { get { return 1; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Base class for all Join operations
///
internal abstract class JoinBaseOp : RelOp
{
#region constructors
internal JoinBaseOp(OpType opType) : base(opType) { }
#endregion
#region public surface
///
/// 3 children - left, right, pred
///
internal override int Arity { get { return 3; } }
#endregion
}
///
/// A CrossJoin (n-way)
///
internal sealed class CrossJoinOp : JoinBaseOp
{
#region constructors
private CrossJoinOp() : base(OpType.CrossJoin) { }
#endregion
#region public methods
///
/// Singleton instance
///
internal static readonly CrossJoinOp Instance = new CrossJoinOp();
internal static readonly CrossJoinOp Pattern = CrossJoinOp.Instance;
///
/// varying number of children (but usually greater than 1)
///
internal override int Arity { get { return ArityVarying; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// An InnerJoin
///
internal sealed class InnerJoinOp : JoinBaseOp
{
#region constructors
private InnerJoinOp() : base(OpType.InnerJoin) { }
#endregion
#region public methods
internal static readonly InnerJoinOp Instance = new InnerJoinOp();
internal static readonly InnerJoinOp Pattern = InnerJoinOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// A LeftOuterJoin
///
internal sealed class LeftOuterJoinOp : JoinBaseOp
{
#region constructors
private LeftOuterJoinOp() : base(OpType.LeftOuterJoin) { }
#endregion
#region public methods
internal static readonly LeftOuterJoinOp Instance = new LeftOuterJoinOp();
internal static readonly LeftOuterJoinOp Pattern = LeftOuterJoinOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// A FullOuterJoin
///
internal sealed class FullOuterJoinOp : JoinBaseOp
{
#region private constructors
private FullOuterJoinOp() : base(OpType.FullOuterJoin) { }
#endregion
#region public methods
internal static readonly FullOuterJoinOp Instance = new FullOuterJoinOp();
internal static readonly FullOuterJoinOp Pattern = FullOuterJoinOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Base class for all Apply Ops
///
internal abstract class ApplyBaseOp : RelOp
{
#region constructors
internal ApplyBaseOp(OpType opType) : base(opType) { }
#endregion
#region public surface
///
/// 2 children - left, right
///
internal override int Arity { get { return 2; } }
#endregion
}
///
/// CrossApply
///
internal sealed class CrossApplyOp : ApplyBaseOp
{
#region constructors
private CrossApplyOp() : base(OpType.CrossApply) { }
#endregion
#region public methods
internal static readonly CrossApplyOp Instance = new CrossApplyOp();
internal static readonly CrossApplyOp Pattern = CrossApplyOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// OuterApply
///
internal sealed class OuterApplyOp : ApplyBaseOp
{
#region constructors
private OuterApplyOp() : base(OpType.OuterApply) { }
#endregion
#region public methods
internal static readonly OuterApplyOp Instance = new OuterApplyOp();
internal static readonly OuterApplyOp Pattern = OuterApplyOp.Instance;
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// FilterOp
///
internal sealed class FilterOp : RelOp
{
#region constructors
private FilterOp() : base(OpType.Filter) { }
#endregion
#region public methods
internal static readonly FilterOp Instance = new FilterOp();
internal static readonly FilterOp Pattern = FilterOp.Instance;
///
/// 2 children - input, pred
///
internal override int Arity { get { return 2; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// ProjectOp
///
internal sealed class ProjectOp : RelOp
{
#region private state
private VarVec m_vars;
#endregion
#region constructors
private ProjectOp()
: base(OpType.Project)
{ }
internal ProjectOp(VarVec vars) : this()
{
Debug.Assert(null != vars, "null vars?");
Debug.Assert(!vars.IsEmpty, "empty varlist?");
m_vars = vars;
}
#endregion
#region public methods
internal static readonly ProjectOp Pattern = new ProjectOp();
///
/// 2 children - input, projections (VarDefList)
///
internal override int Arity { get { return 2; } }
///
/// The Vars projected by this Op
///
internal VarVec Outputs { get { return m_vars; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// A Sortkey
///
internal class SortKey
{
#region private state
private Var m_var;
private bool m_asc;
private string m_collation;
#endregion
#region constructors
internal SortKey(Var v, bool asc, string collation)
{
m_var = v;
m_asc = asc;
m_collation = collation;
}
#endregion
#region public methods
///
/// The Var being sorted
///
internal Var Var
{
get { return m_var; }
set { m_var = value; }
}
///
/// Is this a sort asc, or a sort desc
///
internal bool AscendingSort { get { return m_asc; } }
///
/// An optional collation (only for string types)
///
internal string Collation { get { return m_collation; } }
#endregion
}
///
/// Base type for SortOp and ConstrainedSortOp
///
internal abstract class SortBaseOp : RelOp
{
#region private state
private List m_keys;
#endregion
#region Constructors
// Pattern constructor
internal SortBaseOp(OpType opType)
: base(opType)
{
Debug.Assert(opType == OpType.Sort || opType == OpType.ConstrainedSort, "SortBaseOp OpType must be Sort or ConstrainedSort");
}
internal SortBaseOp(OpType opType, List sortKeys)
: this(opType)
{
m_keys = sortKeys;
}
#endregion
///
/// Sort keys
///
internal List Keys { get { return m_keys; } }
}
///
/// A SortOp
///
internal sealed class SortOp : SortBaseOp
{
#region constructors
private SortOp() : base(OpType.Sort) { }
internal SortOp(List sortKeys) : base(OpType.Sort, sortKeys) {}
#endregion
#region public methods
internal static readonly SortOp Pattern = new SortOp();
///
/// 1 child - the input, SortOp must not contain local VarDefs
///
internal override int Arity { get { return 1; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// A Constrained SortOp. Used to represent physical paging (skip, limit, skip + limit) operations.
///
internal sealed class ConstrainedSortOp : SortBaseOp
{
#region private state
private bool _withTies;
#endregion
#region constructors
// Pattern constructor
private ConstrainedSortOp() : base(OpType.ConstrainedSort) { }
internal ConstrainedSortOp(List sortKeys, bool withTies)
: base(OpType.ConstrainedSort, sortKeys)
{
_withTies = withTies;
}
#endregion
#region public methods
internal bool WithTies { get { return _withTies; } set { _withTies = value; } }
internal static readonly ConstrainedSortOp Pattern = new ConstrainedSortOp();
///
/// 3 children - the input, a possibly NullOp limit and a possibly NullOp skip count.
///
internal override int Arity { get { return 3; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// GroupByOp
///
internal sealed class GroupByOp : RelOp
{
#region private state
private VarVec m_keys;
private VarVec m_outputs;
#endregion
#region constructors
private GroupByOp() : base(OpType.GroupBy) { }
internal GroupByOp(VarVec keys, VarVec outputs)
: this()
{
m_keys = keys;
m_outputs = outputs;
}
#endregion
#region public methods
internal static readonly GroupByOp Pattern = new GroupByOp();
///
/// 3 children - input, keys (vardeflist), aggregates (vardeflist)
///
internal override int Arity { get { return 3; } }
///
/// GroupBy keys
///
internal VarVec Keys { get { return m_keys; } }
///
/// All outputs of this Op - includes keys and aggregates
///
internal VarVec Outputs { get { return m_outputs; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Base class for set operations - union, intersect, except
///
internal abstract class SetOp : RelOp
{
#region private state
private VarMap[] m_varMap;
private VarVec m_outputVars;
#endregion
#region constructors
internal SetOp(OpType opType, VarVec outputs, VarMap left, VarMap right)
: this(opType)
{
m_varMap = new VarMap[2];
m_varMap[0] = left;
m_varMap[1] = right;
m_outputVars = outputs;
}
protected SetOp(OpType opType) : base(opType)
{
}
#endregion
#region public methods
///
/// 2 children - left, right
///
internal override int Arity { get { return 2; } }
///
/// Map of result vars to the vars of each branch of the setOp
///
internal VarMap[] VarMap { get { return m_varMap; } }
///
/// Get the set of output vars produced
///
internal VarVec Outputs { get { return m_outputVars; } }
#endregion
}
///
/// UnionAll (ie) no duplicate elimination
///
internal sealed class UnionAllOp : SetOp
{
#region private state
private Var m_branchDiscriminator;
#endregion
#region constructors
private UnionAllOp() : base(OpType.UnionAll) { }
internal UnionAllOp(VarVec outputs, VarMap left, VarMap right, Var branchDiscriminator) : base(OpType.UnionAll, outputs, left, right)
{
m_branchDiscriminator = branchDiscriminator;
}
#endregion
#region public methods
internal static readonly UnionAllOp Pattern = new UnionAllOp();
///
/// Returns the branch discriminator var for this op. It may be null, if
/// we haven't been through key pullup yet.
///
internal Var BranchDiscriminator { get { return m_branchDiscriminator; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// An IntersectOp
///
internal sealed class IntersectOp : SetOp
{
#region constructors
private IntersectOp() : base(OpType.Intersect) { }
internal IntersectOp(VarVec outputs, VarMap left, VarMap right) : base(OpType.Intersect, outputs, left,right) { }
#endregion
#region public methods
internal static readonly IntersectOp Pattern = new IntersectOp();
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// ExceptOp (Minus)
///
internal sealed class ExceptOp : SetOp
{
#region constructors
private ExceptOp() : base(OpType.Except) { }
internal ExceptOp(VarVec outputs, VarMap left, VarMap right) : base(OpType.Except, outputs, left, right) { }
#endregion
#region public methods
internal static readonly ExceptOp Pattern = new ExceptOp();
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// DistinctOp
///
internal sealed class DistinctOp : RelOp
{
#region private state
private VarVec m_keys;
#endregion
#region constructors
private DistinctOp() : base(OpType.Distinct)
{
}
internal DistinctOp(VarVec keyVars) : this()
{
Debug.Assert(keyVars != null);
Debug.Assert(!keyVars.IsEmpty);
m_keys = keyVars;
}
#endregion
#region public methods
internal static readonly DistinctOp Pattern = new DistinctOp();
///
/// 1 child - input
///
internal override int Arity { get { return 1; } }
///
/// Get "key" vars for the distinct
///
internal VarVec Keys { get { return m_keys; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Selects out a single row from a underlying subquery. Two flavors of this Op exist.
/// The first flavor enforces the single-row-ness (ie) an error is raised if the
/// underlying subquery produces more than one row.
/// The other flavor simply choses any row from the input
///
internal sealed class SingleRowOp : RelOp
{
#region constructors
private SingleRowOp() : base(OpType.SingleRow) { }
#endregion
#region public methods
///
/// Singleton instance
///
internal static readonly SingleRowOp Instance = new SingleRowOp();
///
/// Pattern for transformation rules
///
internal static readonly SingleRowOp Pattern = Instance;
///
/// 1 child - input
///
internal override int Arity { get { return 1; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#endregion
}
///
/// Represents a table with a single row
///
internal sealed class SingleRowTableOp : RelOp
{
#region constructors
private SingleRowTableOp() : base(OpType.SingleRowTable) { }
#endregion
#region public methods
///
/// Singleton instance
///
internal static readonly SingleRowTableOp Instance = new SingleRowTableOp();
///
/// Pattern for transformation rules
///
internal static readonly SingleRowTableOp Pattern = Instance;
///
/// 0 children
///
internal override int Arity { get { return 0; } }
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
///
/// Visitor pattern method for visitors with a return value
///
/// The visitor
/// The node in question
/// An instance of TResultType
[DebuggerNonUserCode]
internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
#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
- _IPv6Address.cs
- NameTable.cs
- XamlSerializerUtil.cs
- ContextTokenTypeConverter.cs
- TemplateColumn.cs
- DataGridPageChangedEventArgs.cs
- SQLGuid.cs
- TextAction.cs
- RawTextInputReport.cs
- PartManifestEntry.cs
- FormatConvertedBitmap.cs
- TableDetailsCollection.cs
- URLIdentityPermission.cs
- StylusDevice.cs
- StylusShape.cs
- ConnectivityStatus.cs
- PropertyOverridesTypeEditor.cs
- HasCopySemanticsAttribute.cs
- X509RawDataKeyIdentifierClause.cs
- XmlEventCache.cs
- SecurityUtils.cs
- SinglePageViewer.cs
- DaylightTime.cs
- PenContexts.cs
- EntityDataSourceWrapper.cs
- TileBrush.cs
- WebEventTraceProvider.cs
- DataFieldCollectionEditor.cs
- StylusOverProperty.cs
- AlignmentYValidation.cs
- StringFreezingAttribute.cs
- EntitySet.cs
- FixedLineResult.cs
- CheckPair.cs
- RectAnimation.cs
- TreeNodeConverter.cs
- Avt.cs
- MessageDecoder.cs
- ImageFormatConverter.cs
- IgnorePropertiesAttribute.cs
- SettingsContext.cs
- DrawingBrush.cs
- IISUnsafeMethods.cs
- MethodBuilderInstantiation.cs
- cookiecollection.cs
- ContainerSelectorBehavior.cs
- StateMachineAction.cs
- ComAdminWrapper.cs
- PropertyMappingExceptionEventArgs.cs
- Message.cs
- PolicyManager.cs
- DesignerMetadata.cs
- BitmapEffectInputData.cs
- DependentList.cs
- File.cs
- __FastResourceComparer.cs
- Normalizer.cs
- BindingContext.cs
- __Filters.cs
- GridViewRow.cs
- DisposableCollectionWrapper.cs
- FormViewDeletedEventArgs.cs
- SoapFormatter.cs
- FunctionImportMapping.ReturnTypeRenameMapping.cs
- DataGridViewRowConverter.cs
- Closure.cs
- ProfileGroupSettings.cs
- HttpCachePolicy.cs
- WebPartZoneBase.cs
- TextTreeTextElementNode.cs
- ShaderEffect.cs
- MethodCallTranslator.cs
- ReadOnlyDataSourceView.cs
- CollaborationHelperFunctions.cs
- PeerNameRegistration.cs
- XmlSchemaComplexContentRestriction.cs
- MenuItem.cs
- PtsContext.cs
- DataStorage.cs
- ValidatingReaderNodeData.cs
- DataGridViewRowContextMenuStripNeededEventArgs.cs
- EditorZoneAutoFormat.cs
- XmlSchemaAll.cs
- configsystem.cs
- Function.cs
- SpecularMaterial.cs
- BindableTemplateBuilder.cs
- DataFormats.cs
- DecimalConstantAttribute.cs
- TimersDescriptionAttribute.cs
- CqlErrorHelper.cs
- BitmapEffectInput.cs
- CategoryEditor.cs
- XmlMembersMapping.cs
- HelpProvider.cs
- DropTarget.cs
- HttpListenerResponse.cs
- IPCCacheManager.cs
- LookupNode.cs
- TrustSection.cs