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
- ByteConverter.cs
- StylusPointProperty.cs
- XmlEntityReference.cs
- HostSecurityManager.cs
- DropShadowEffect.cs
- CompoundFileStorageReference.cs
- SpeechAudioFormatInfo.cs
- ColorContext.cs
- MatrixKeyFrameCollection.cs
- WindowsSolidBrush.cs
- FontFamily.cs
- _DigestClient.cs
- HMACMD5.cs
- OraclePermission.cs
- HttpHandler.cs
- ToolStripCodeDomSerializer.cs
- AstTree.cs
- XmlIlVisitor.cs
- EventPrivateKey.cs
- WizardForm.cs
- RtfToXamlReader.cs
- DateTimeFormat.cs
- TypeProvider.cs
- DataGridColumnHeadersPresenterAutomationPeer.cs
- PersonalizationEntry.cs
- RegularExpressionValidator.cs
- MappedMetaModel.cs
- UserControlParser.cs
- Properties.cs
- _LocalDataStoreMgr.cs
- CancelRequestedRecord.cs
- Pen.cs
- ReaderWriterLock.cs
- QilPatternVisitor.cs
- Rotation3DAnimation.cs
- DoWorkEventArgs.cs
- PageContentCollection.cs
- WindowsGraphicsWrapper.cs
- HtmlInputHidden.cs
- nulltextcontainer.cs
- InlineObject.cs
- WinFormsSpinner.cs
- WorkflowRuntimeBehavior.cs
- NetworkStream.cs
- ListViewItemEventArgs.cs
- WorkflowServiceOperationListItem.cs
- DocumentNUp.cs
- DataRelationCollection.cs
- XmlSchemaImport.cs
- WebServiceHandlerFactory.cs
- LookupBindingPropertiesAttribute.cs
- SecurityResources.cs
- ILGenerator.cs
- SqlDependencyListener.cs
- HebrewNumber.cs
- XmlSchemaProviderAttribute.cs
- TransactionState.cs
- Visual3DCollection.cs
- DesignOnlyAttribute.cs
- DocumentSignatureManager.cs
- PaperSource.cs
- SchemaNames.cs
- DispatcherOperation.cs
- RequestUriProcessor.cs
- AnnouncementDispatcherAsyncResult.cs
- CountdownEvent.cs
- CryptoStream.cs
- AutomationPropertyInfo.cs
- FlowPanelDesigner.cs
- OpenFileDialog.cs
- XpsSerializationManagerAsync.cs
- DPCustomTypeDescriptor.cs
- PersonalizationStateQuery.cs
- XmlSchemaType.cs
- ZipIOCentralDirectoryDigitalSignature.cs
- BindingCollection.cs
- TemplateComponentConnector.cs
- WebPartDeleteVerb.cs
- JsonFormatWriterGenerator.cs
- ControlCodeDomSerializer.cs
- GeometryConverter.cs
- SafeViewOfFileHandle.cs
- SystemTcpConnection.cs
- ScriptIgnoreAttribute.cs
- MarkerProperties.cs
- UnsafeNativeMethods.cs
- ThrowHelper.cs
- DocumentGrid.cs
- DataBinder.cs
- XmlIgnoreAttribute.cs
- CodeCatchClause.cs
- LogSwitch.cs
- ButtonChrome.cs
- DispatcherProcessingDisabled.cs
- XmlEntity.cs
- ExpressionEditorAttribute.cs
- AccessedThroughPropertyAttribute.cs
- DragDeltaEventArgs.cs
- ServiceXNameTypeConverter.cs
- WindowProviderWrapper.cs