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
- ChangeDirector.cs
- XmlEntity.cs
- Popup.cs
- HttpConfigurationContext.cs
- ReadOnlyDataSource.cs
- CalendarBlackoutDatesCollection.cs
- EngineSiteSapi.cs
- PartManifestEntry.cs
- IntersectQueryOperator.cs
- LogStore.cs
- CfgRule.cs
- TextPointer.cs
- AppPool.cs
- AsmxEndpointPickerExtension.cs
- IgnoreFileBuildProvider.cs
- EditCommandColumn.cs
- DataGridViewButtonCell.cs
- DataPagerField.cs
- MemoryStream.cs
- PenLineJoinValidation.cs
- ScrollItemProviderWrapper.cs
- GridViewRowCollection.cs
- DependencyPropertyValueSerializer.cs
- GridViewUpdatedEventArgs.cs
- AuthenticatedStream.cs
- SafeFileMappingHandle.cs
- HttpProfileGroupBase.cs
- CodeTypeDeclaration.cs
- AttributedMetaModel.cs
- DataGridViewIntLinkedList.cs
- ReaderWriterLock.cs
- MulticastDelegate.cs
- DbgUtil.cs
- WebControlsSection.cs
- DrawingDrawingContext.cs
- Track.cs
- FontUnitConverter.cs
- CodeSubDirectoriesCollection.cs
- SafeNativeMethods.cs
- DataGridViewEditingControlShowingEventArgs.cs
- DataGrid.cs
- VarInfo.cs
- UnsafeNativeMethods.cs
- ActionFrame.cs
- HttpApplication.cs
- IRCollection.cs
- BitmapData.cs
- SortableBindingList.cs
- AutoSizeToolBoxItem.cs
- AmbientProperties.cs
- CustomAttributeFormatException.cs
- XPathNodeIterator.cs
- CatchBlock.cs
- InternalCache.cs
- CodeMethodReturnStatement.cs
- TextEndOfParagraph.cs
- EraserBehavior.cs
- BaseCodePageEncoding.cs
- XmlChildEnumerator.cs
- DelayedRegex.cs
- TextTrailingWordEllipsis.cs
- TypeContext.cs
- EdmConstants.cs
- CopyAction.cs
- EdmItemError.cs
- DesignTimeTemplateParser.cs
- SubclassTypeValidatorAttribute.cs
- MouseBinding.cs
- CrossAppDomainChannel.cs
- DBCommandBuilder.cs
- VirtualPathUtility.cs
- FacetChecker.cs
- CallContext.cs
- DesignerOptions.cs
- FixedDSBuilder.cs
- DataServiceBuildProvider.cs
- DataGridViewCheckBoxCell.cs
- BuildProvidersCompiler.cs
- Menu.cs
- MetadataImporterQuotas.cs
- ExpressionBuilder.cs
- FilterQuery.cs
- ListViewItemCollectionEditor.cs
- ScrollEventArgs.cs
- ManagedFilter.cs
- BoolExpr.cs
- NumberFunctions.cs
- DataObjectAttribute.cs
- ContentDisposition.cs
- _SslSessionsCache.cs
- CodeIndexerExpression.cs
- CheckableControlBaseAdapter.cs
- VectorAnimationBase.cs
- InstanceHandleConflictException.cs
- ImageList.cs
- DoubleSumAggregationOperator.cs
- UserNameSecurityTokenProvider.cs
- ToolStripKeyboardHandlingService.cs
- DeclaredTypeElement.cs
- VirtualPathData.cs