Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / ndp / fx / src / DataEntity / System / Data / Query / InternalTrees / Ops.cs / 1 / Ops.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Data.Metadata.Edm;
using System.Globalization;
using System.Diagnostics;
namespace System.Data.Query.InternalTrees
{
///
/// The operator types. Includes both scalar and relational operators,
/// and physical and logical operators, and rule operators
///
internal enum OpType
{
#region ScalarOpType
///
/// Constants
///
Constant,
///
/// An internally generated constant
///
InternalConstant,
///
/// A null constant
///
Null,
///
/// ConstantPredicate
///
ConstantPredicate,
///
/// A Var reference
///
VarRef,
///
/// GreaterThan
///
GT,
///
/// >=
///
GE,
///
/// Lessthan or equals
///
LE,
///
/// Less than
///
LT,
///
/// Equals
///
EQ,
///
/// Not equals
///
NE,
///
/// String comparison
///
Like,
///
/// Addition
///
Plus,
///
/// Subtraction
///
Minus,
///
/// Multiplication
///
Multiply,
///
/// Division
///
Divide,
///
/// Modulus
///
Modulo,
///
/// Unary Minus
///
UnaryMinus,
///
/// And
///
And,
///
/// Or
///
Or,
///
/// Not
///
Not,
///
/// is null
///
IsNull,
///
/// switched case expression
///
Case,
///
/// treat-as
///
Treat,
///
/// is-of
///
IsOf,
///
/// Cast
///
Cast,
///
/// Internal cast
///
SoftCast,
///
/// a basic aggregate
///
Aggregate,
///
/// function call
///
Function,
///
/// Reference to a "relationship" property
///
RelProperty,
///
/// property reference
///
Property,
///
/// entity constructor
///
NewEntity,
///
/// new instance constructor for a named type(other than multiset, record)
///
NewInstance,
///
/// new instance constructor for a named type and sub-types
///
DiscriminatedNewEntity,
///
/// Multiset constructor
///
NewMultiset,
///
/// record constructor
///
NewRecord,
///
/// Get the key from a Ref
///
GetRefKey,
///
/// Get the ref from an entity instance
///
GetEntityRef,
///
/// create a reference
///
Ref,
///
/// exists
///
Exists,
///
/// get the singleton element from a collection
///
Element,
///
/// Builds up a collection
///
Collect,
///
/// gets the target entity pointed at by a reference
///
Deref,
///
/// Traverse a relationship and get the references of the other end
///
Navigate,
#endregion
#region RelOpType
///
/// A table scan
///
ScanTable,
///
/// A view scan
///
ScanView,
///
/// Filter
///
Filter,
///
/// Project
///
Project,
///
/// InnerJoin
///
InnerJoin,
///
/// LeftOuterJoin
///
LeftOuterJoin,
///
/// FullOuter join
///
FullOuterJoin,
///
/// Cross join
///
CrossJoin,
///
/// cross apply
///
CrossApply,
///
/// outer apply
///
OuterApply,
///
/// Unnest
///
Unnest,
///
/// Sort
///
Sort,
///
/// Constrained Sort (physical paging - Limit and Skip)
///
ConstrainedSort,
///
/// GroupBy
///
GroupBy,
///
/// UnionAll
///
UnionAll,
///
/// Intersect
///
Intersect,
///
/// Except
///
Except,
///
/// Distinct
///
Distinct,
///
/// Select a single row from a subquery
///
SingleRow,
///
/// A table with exactly one row
///
SingleRowTable,
#endregion
#region AncillaryOpType
///
/// Variable definition
///
VarDef,
///
/// List of variable definitions
///
VarDefList,
#endregion
#region RulePatternOpType
///
/// Leaf
///
Leaf,
#endregion
#region PhysicalOpType
///
/// Physical Project
///
PhysicalProject,
///
/// single-stream nest aggregation
///
SingleStreamNest,
///
/// multi-stream nest aggregation
///
MultiStreamNest,
#endregion
///
/// NotValid
///
MaxMarker,
NotValid = MaxMarker
}
///
/// Represents an operator
///
internal abstract class Op
{
#region private state
private OpType m_opType;
#endregion
#region constructors
///
/// Basic constructor
///
internal Op(OpType opType)
{
m_opType = opType;
}
#endregion
#region public methods
///
/// Represents an unknown arity. Usually for Ops that can have a varying number of Args
///
internal const int ArityVarying = -1;
///
/// Kind of Op
///
internal OpType OpType { get { return m_opType; } }
///
/// The Arity of this Op (ie) how many arguments can it have.
/// Returns -1 if the arity is not known a priori
///
internal virtual int Arity { get { return ArityVarying; } }
///
/// Is this a ScalarOp
///
internal virtual bool IsScalarOp { get { return false; } }
///
/// Is this a RulePatternOp
///
internal virtual bool IsRulePatternOp { get { return false; } }
///
/// Is this a RelOp
///
internal virtual bool IsRelOp { get { return false; } }
///
/// Is this an AncillaryOp
///
internal virtual bool IsAncillaryOp { get { return false; } }
///
/// Is this a PhysicalOp
///
internal virtual bool IsPhysicalOp { get { return false; } }
///
/// Is the other Op equivalent?
///
/// the other Op to compare
/// true, if the Ops are equivalent
internal virtual bool? IsEquivalent(Op other)
{
return false;
}
///
/// Simple mechanism to get the type for an Op. Applies only to scalar and ancillaryOps
///
internal virtual TypeUsage Type
{
get { return null; }
set { throw System.Data.Entity.Error.NotSupported(); }
}
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal virtual 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 virtual TResultType Accept(BasicOpVisitorOfT v, Node n)
{
return v.Visit(this, n);
}
#endregion
}
///
/// All scalars fall into this category
///
internal abstract class ScalarOp : Op
{
#region private state
private TypeUsage m_type;
#endregion
#region constructors
///
/// Default constructor
///
/// kind of Op
/// type of value produced by this Op
internal ScalarOp(OpType opType, TypeUsage type)
: this(opType)
{
Debug.Assert(type != null, "No type specified for ScalarOp");
m_type = type;
}
protected ScalarOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// ScalarOp
///
internal override bool IsScalarOp { get { return true; } }
///
/// Two scalarOps are equivalent (usually) if their OpTypes and types are the
/// same. Obviously, their arguments need to be equivalent as well - but that's
/// checked elsewhere
///
/// The other Op to compare against
/// true, if the Ops are indeed equivalent
internal override bool? IsEquivalent(Op other)
{
return (other.OpType == this.OpType && TypeSemantics.IsEquivalent(this.Type, other.Type));
}
///
/// Datatype of result
///
internal override TypeUsage Type
{
get { return m_type; }
set { m_type = value; }
}
///
/// Is this an Aggregate
///
internal virtual bool IsAggregateOp
{
get{return false;}
}
#endregion
}
///
/// All relational operators - filter, project, join etc.
///
internal abstract class RelOp : Op
{
#region constructors
///
/// Basic constructor.
///
/// kind of Op
internal RelOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// RelOp
///
internal override bool IsRelOp { get { return true; } }
#endregion
}
///
/// AncillaryOp
///
internal abstract class AncillaryOp : Op
{
#region constructors
///
/// Default constructor
///
/// kind of Op
internal AncillaryOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// AncillaryOp
///
internal override bool IsAncillaryOp { get { return true; } }
#endregion
}
///
/// Represents all physical operators
///
internal abstract class PhysicalOp : Op
{
#region constructors
///
/// Default constructor
///
/// the op type
internal PhysicalOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// This is a physical Op
///
internal override bool IsPhysicalOp { get { return true; } }
#endregion
}
///
/// All rule pattern operators - Leaf, Tree
///
internal abstract class RulePatternOp : Op
{
#region constructors
///
/// Default constructor
///
/// kind of Op
internal RulePatternOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// RulePatternOp
///
internal override bool IsRulePatternOp { get { return true; } }
#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.Globalization;
using System.Diagnostics;
namespace System.Data.Query.InternalTrees
{
///
/// The operator types. Includes both scalar and relational operators,
/// and physical and logical operators, and rule operators
///
internal enum OpType
{
#region ScalarOpType
///
/// Constants
///
Constant,
///
/// An internally generated constant
///
InternalConstant,
///
/// A null constant
///
Null,
///
/// ConstantPredicate
///
ConstantPredicate,
///
/// A Var reference
///
VarRef,
///
/// GreaterThan
///
GT,
///
/// >=
///
GE,
///
/// Lessthan or equals
///
LE,
///
/// Less than
///
LT,
///
/// Equals
///
EQ,
///
/// Not equals
///
NE,
///
/// String comparison
///
Like,
///
/// Addition
///
Plus,
///
/// Subtraction
///
Minus,
///
/// Multiplication
///
Multiply,
///
/// Division
///
Divide,
///
/// Modulus
///
Modulo,
///
/// Unary Minus
///
UnaryMinus,
///
/// And
///
And,
///
/// Or
///
Or,
///
/// Not
///
Not,
///
/// is null
///
IsNull,
///
/// switched case expression
///
Case,
///
/// treat-as
///
Treat,
///
/// is-of
///
IsOf,
///
/// Cast
///
Cast,
///
/// Internal cast
///
SoftCast,
///
/// a basic aggregate
///
Aggregate,
///
/// function call
///
Function,
///
/// Reference to a "relationship" property
///
RelProperty,
///
/// property reference
///
Property,
///
/// entity constructor
///
NewEntity,
///
/// new instance constructor for a named type(other than multiset, record)
///
NewInstance,
///
/// new instance constructor for a named type and sub-types
///
DiscriminatedNewEntity,
///
/// Multiset constructor
///
NewMultiset,
///
/// record constructor
///
NewRecord,
///
/// Get the key from a Ref
///
GetRefKey,
///
/// Get the ref from an entity instance
///
GetEntityRef,
///
/// create a reference
///
Ref,
///
/// exists
///
Exists,
///
/// get the singleton element from a collection
///
Element,
///
/// Builds up a collection
///
Collect,
///
/// gets the target entity pointed at by a reference
///
Deref,
///
/// Traverse a relationship and get the references of the other end
///
Navigate,
#endregion
#region RelOpType
///
/// A table scan
///
ScanTable,
///
/// A view scan
///
ScanView,
///
/// Filter
///
Filter,
///
/// Project
///
Project,
///
/// InnerJoin
///
InnerJoin,
///
/// LeftOuterJoin
///
LeftOuterJoin,
///
/// FullOuter join
///
FullOuterJoin,
///
/// Cross join
///
CrossJoin,
///
/// cross apply
///
CrossApply,
///
/// outer apply
///
OuterApply,
///
/// Unnest
///
Unnest,
///
/// Sort
///
Sort,
///
/// Constrained Sort (physical paging - Limit and Skip)
///
ConstrainedSort,
///
/// GroupBy
///
GroupBy,
///
/// UnionAll
///
UnionAll,
///
/// Intersect
///
Intersect,
///
/// Except
///
Except,
///
/// Distinct
///
Distinct,
///
/// Select a single row from a subquery
///
SingleRow,
///
/// A table with exactly one row
///
SingleRowTable,
#endregion
#region AncillaryOpType
///
/// Variable definition
///
VarDef,
///
/// List of variable definitions
///
VarDefList,
#endregion
#region RulePatternOpType
///
/// Leaf
///
Leaf,
#endregion
#region PhysicalOpType
///
/// Physical Project
///
PhysicalProject,
///
/// single-stream nest aggregation
///
SingleStreamNest,
///
/// multi-stream nest aggregation
///
MultiStreamNest,
#endregion
///
/// NotValid
///
MaxMarker,
NotValid = MaxMarker
}
///
/// Represents an operator
///
internal abstract class Op
{
#region private state
private OpType m_opType;
#endregion
#region constructors
///
/// Basic constructor
///
internal Op(OpType opType)
{
m_opType = opType;
}
#endregion
#region public methods
///
/// Represents an unknown arity. Usually for Ops that can have a varying number of Args
///
internal const int ArityVarying = -1;
///
/// Kind of Op
///
internal OpType OpType { get { return m_opType; } }
///
/// The Arity of this Op (ie) how many arguments can it have.
/// Returns -1 if the arity is not known a priori
///
internal virtual int Arity { get { return ArityVarying; } }
///
/// Is this a ScalarOp
///
internal virtual bool IsScalarOp { get { return false; } }
///
/// Is this a RulePatternOp
///
internal virtual bool IsRulePatternOp { get { return false; } }
///
/// Is this a RelOp
///
internal virtual bool IsRelOp { get { return false; } }
///
/// Is this an AncillaryOp
///
internal virtual bool IsAncillaryOp { get { return false; } }
///
/// Is this a PhysicalOp
///
internal virtual bool IsPhysicalOp { get { return false; } }
///
/// Is the other Op equivalent?
///
/// the other Op to compare
/// true, if the Ops are equivalent
internal virtual bool? IsEquivalent(Op other)
{
return false;
}
///
/// Simple mechanism to get the type for an Op. Applies only to scalar and ancillaryOps
///
internal virtual TypeUsage Type
{
get { return null; }
set { throw System.Data.Entity.Error.NotSupported(); }
}
///
/// Visitor pattern method
///
/// The BasicOpVisitor that is visiting this Op
/// The Node that references this Op
[DebuggerNonUserCode]
internal virtual 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 virtual TResultType Accept(BasicOpVisitorOfT v, Node n)
{
return v.Visit(this, n);
}
#endregion
}
///
/// All scalars fall into this category
///
internal abstract class ScalarOp : Op
{
#region private state
private TypeUsage m_type;
#endregion
#region constructors
///
/// Default constructor
///
/// kind of Op
/// type of value produced by this Op
internal ScalarOp(OpType opType, TypeUsage type)
: this(opType)
{
Debug.Assert(type != null, "No type specified for ScalarOp");
m_type = type;
}
protected ScalarOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// ScalarOp
///
internal override bool IsScalarOp { get { return true; } }
///
/// Two scalarOps are equivalent (usually) if their OpTypes and types are the
/// same. Obviously, their arguments need to be equivalent as well - but that's
/// checked elsewhere
///
/// The other Op to compare against
/// true, if the Ops are indeed equivalent
internal override bool? IsEquivalent(Op other)
{
return (other.OpType == this.OpType && TypeSemantics.IsEquivalent(this.Type, other.Type));
}
///
/// Datatype of result
///
internal override TypeUsage Type
{
get { return m_type; }
set { m_type = value; }
}
///
/// Is this an Aggregate
///
internal virtual bool IsAggregateOp
{
get{return false;}
}
#endregion
}
///
/// All relational operators - filter, project, join etc.
///
internal abstract class RelOp : Op
{
#region constructors
///
/// Basic constructor.
///
/// kind of Op
internal RelOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// RelOp
///
internal override bool IsRelOp { get { return true; } }
#endregion
}
///
/// AncillaryOp
///
internal abstract class AncillaryOp : Op
{
#region constructors
///
/// Default constructor
///
/// kind of Op
internal AncillaryOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// AncillaryOp
///
internal override bool IsAncillaryOp { get { return true; } }
#endregion
}
///
/// Represents all physical operators
///
internal abstract class PhysicalOp : Op
{
#region constructors
///
/// Default constructor
///
/// the op type
internal PhysicalOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// This is a physical Op
///
internal override bool IsPhysicalOp { get { return true; } }
#endregion
}
///
/// All rule pattern operators - Leaf, Tree
///
internal abstract class RulePatternOp : Op
{
#region constructors
///
/// Default constructor
///
/// kind of Op
internal RulePatternOp(OpType opType) : base(opType) { }
#endregion
#region public methods
///
/// RulePatternOp
///
internal override bool IsRulePatternOp { get { return true; } }
#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
- UnsafeNativeMethods.cs
- SecurityUniqueId.cs
- CursorConverter.cs
- ChooseAction.cs
- Monitor.cs
- ScriptIgnoreAttribute.cs
- HotSpot.cs
- InitializationEventAttribute.cs
- Visual3D.cs
- DataGridrowEditEndingEventArgs.cs
- ZipFileInfo.cs
- InternalCache.cs
- TargetException.cs
- DataViewManager.cs
- ColumnMapTranslator.cs
- StaticFileHandler.cs
- MessageFault.cs
- XmlCDATASection.cs
- EntityContainer.cs
- DataKey.cs
- KoreanLunisolarCalendar.cs
- MetabaseSettings.cs
- _IPv4Address.cs
- XmlToDatasetMap.cs
- thaishape.cs
- RoutedEventValueSerializer.cs
- RichTextBoxAutomationPeer.cs
- WindowsSecurityToken.cs
- ThemeableAttribute.cs
- RegexRunner.cs
- HtmlInputFile.cs
- HeaderedItemsControl.cs
- WebBrowserNavigatingEventHandler.cs
- AnimationStorage.cs
- MouseEventArgs.cs
- DataRelation.cs
- Mapping.cs
- Drawing.cs
- WebPartEditorCancelVerb.cs
- BuildDependencySet.cs
- DbDeleteCommandTree.cs
- DbException.cs
- CustomLineCap.cs
- GenericWebPart.cs
- _LazyAsyncResult.cs
- AccessorTable.cs
- ListViewCancelEventArgs.cs
- NameValuePermission.cs
- XmlDataImplementation.cs
- SqlDependencyListener.cs
- SQLSingleStorage.cs
- ExtendedProperty.cs
- SqlDataSourceCache.cs
- XmlWhitespace.cs
- BindingValueChangedEventArgs.cs
- DesignerAttribute.cs
- PassportAuthenticationEventArgs.cs
- FormatVersion.cs
- FrameworkContentElementAutomationPeer.cs
- EntryPointNotFoundException.cs
- StructuredTypeInfo.cs
- FileDataSourceCache.cs
- PassportAuthenticationEventArgs.cs
- WebPermission.cs
- PrintDialog.cs
- VirtualizingStackPanel.cs
- MdbDataFileEditor.cs
- Matrix.cs
- BinaryReader.cs
- UriParserTemplates.cs
- TimeEnumHelper.cs
- XhtmlBasicLinkAdapter.cs
- TreeNodeSelectionProcessor.cs
- DataGridAutoGeneratingColumnEventArgs.cs
- XmlValidatingReaderImpl.cs
- HttpRequest.cs
- __TransparentProxy.cs
- SafeEventLogReadHandle.cs
- QuaternionKeyFrameCollection.cs
- PageThemeBuildProvider.cs
- SafeWaitHandle.cs
- _NegoStream.cs
- XmlILAnnotation.cs
- LeaseManager.cs
- WebPartVerb.cs
- ResourceAssociationSet.cs
- ReturnEventArgs.cs
- GregorianCalendarHelper.cs
- translator.cs
- PerformanceCounterPermission.cs
- EntityDesignerBuildProvider.cs
- MSAAEventDispatcher.cs
- Console.cs
- SymDocumentType.cs
- VectorValueSerializer.cs
- FullTextLine.cs
- OptionUsage.cs
- WebPartConnectionCollection.cs
- MatrixAnimationUsingKeyFrames.cs
- AssemblyNameProxy.cs