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 / Common / CommandTrees / DbCommandTree.cs / 1 / DbCommandTree.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Common;
using System.Globalization;
using System.IO;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.Data.Common.Utils;
using System.Data.Metadata.Edm;
using System.Data.Common.CommandTrees.Internal;
namespace System.Data.Common.CommandTrees
{
///
/// DbCommandTree is the abstract base type for the Delete, Query, Insert and Update DbCommandTree types.
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
public abstract class DbCommandTree
{
#region Private Instance Fields
// Metadata collection
private MetadataWorkspace _metadata;
private DataSpace _dataSpace;
// Commonly used types
private CommandTreeTypeHelper _typeHelp;
// CreateParameter Support
private Dictionary> _paramMappings = new Dictionary>(StringComparer.OrdinalIgnoreCase);
// Pre-built Expressions
DbConstantExpression _trueExpr;
DbConstantExpression _falseExpr;
// Validation support
private int _currentVersion = 1;
private int _validatedVersion;
// Referenced Container Tracking
private List _containers = new List();
// Binding alias generation
private AliasGenerator _bindingAliases;
internal AliasGenerator BindingAliases
{
get
{
if (null == _bindingAliases)
{
_bindingAliases = new AliasGenerator(string.Format(CultureInfo.InvariantCulture, "Var_{0}_", this.ObjectId), 0);
}
return _bindingAliases;
}
}
private static int s_instanceCount; // Bid counter
internal readonly int ObjectId = System.Threading.Interlocked.Increment(ref s_instanceCount);
#endregion
#region Constructors
///
/// Initializes a new command tree with a given metadata workspace.
///
/// The metadata workspace against which the command tree should operate.
/// The logical 'space' that metadata in the expressions used in this command tree must belong to.
/// %d#", this.ObjectId))
{
if (null == metadata)
{
throw EntityUtil.ArgumentNull("metadata");
}
//
// Ensure that this is a valid value, in addition to non-null
//
if (!CommandTreeUtils.IsValidDataSpace(dataSpace))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_InvalidDataSpace, "dataSpace");
}
//
// Assign the metadata workspace and initalize commonly used types.
//
_metadata = new MetadataWorkspace();
ItemCollection objectItemCollection;
//While EdmItemCollection and StorageitemCollections are required
//ObjectItemCollection may or may not be registered on the workspace yet.
//So register the ObjectItemCollection if it exists.
if (metadata.TryGetItemCollection(DataSpace.OSpace, out objectItemCollection))
{
_metadata.RegisterItemCollection(objectItemCollection);
}
_metadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSpace));
_metadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSSpace));
_metadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.SSpace));
_dataSpace = dataSpace;
_typeHelp = new CommandTreeTypeHelper(this);
}
}
#endregion
#region Public API
///
/// Clones the specified
/// The expression to import
/// If the expression is already owned by this command tree, the original expression. Otherwise, a copy of the expression that is owned by this command tree
/// %d#", this.ObjectId))
{
EntityBid.Trace(" %d#, source=%d#, %d{cqt.DbExpressionKind}\n", this.ObjectId, DbExpression.GetObjectId(source), DbExpression.GetExpressionKind(source));
if (this == source.CommandTree)
{
return source;
}
// Command Trees should only ever exist in one Data Space, the C-Space.
//Debug.Assert(source.CommandTree.DataSpace == this.DataSpace, "DbCommandTree DataSpace mismatch");
return ExpressionCopier.Copy(this, source);
}
}
///
/// Verifies that the command tree is valid, including the validity of variable and parameter references.
///
/// If the command tree is invalid
/*CQT_PUBLIC_API(*/internal/*)*/ void Validate()
{
using(new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
if (!this.ValidationRequired)
{
return;
}
this.Validate(new System.Data.Common.CommandTrees.Internal.Validator());
this.SetValid();
}
}
///
/// Adds a parameter to the set of parameters that may be referenced within this command tree. If a parameter with the same name but a different type already exists on this command tree then an exception will be thrown.
///
/// The name of the new parameter
/// A description of the type of the new parameter
/// A parameter with the same name but a different type already exists on this command tree.
/*CQT_PUBLIC_API(*/internal/*)*/ void AddParameter(string name, TypeUsage type)
{
EntityUtil.CheckArgumentNull(name, "name");
this.TypeHelper.CheckType(type);
using(new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
EntityBid.Trace(" %d#, name='%ls'\n", this.ObjectId, name);
EntityBid.Trace(" %d#, type='%ls'\n", this.ObjectId, TypeHelpers.GetStrongName(type));
if (!DbCommandTree.IsValidParameterName(name))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_InvalidParameterName(name), "name");
}
KeyValuePair foundParam;
if (_paramMappings.TryGetValue(name, out foundParam))
{
// SQLBUDT#545720: Equivalence is not a sufficient check (consider row types for TVPs) - equality is required.
if (!TypeSemantics.IsStructurallyEqualTo(type, foundParam.Value))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_ParameterExists, "type");
}
}
else
{
_paramMappings.Add(name, new KeyValuePair(name, type));
}
}
}
///
/// Gets the name and corresponding type of each parameter that can be referenced within this command tree.
///
public IEnumerable> Parameters
{
get
{
using(new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
Dictionary retParams = new Dictionary();
foreach (KeyValuePair definedParam in _paramMappings.Values)
{
EntityBid.Trace(" %d#, name='%ls'\n", this.ObjectId, definedParam.Key);
EntityBid.Trace(" %d#, type='%ls'\n", this.ObjectId, TypeHelpers.GetStrongName(definedParam.Value));
retParams.Add(definedParam.Key, definedParam.Value);
}
return retParams;
}
}
}
// VersionNumber need only be public when Command Trees are mutable.
#if PUBLIC_COMMANDTREE_VERSIONNUMBER
///
/// Gets the current version of this DbCommandTree.
///
public int VersionNumber { get { return _currentVersion; } }
#endif
#region Non-DbExpression Factory Methods
///
/// Creates a new
/// The expression to bind
/// The variable name that should be used for the binding
/// A new expression binding with the specified expression and variable name
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbExpressionBinding CreateExpressionBinding(DbExpression input, string varName)
{
return new DbExpressionBinding(this, input, varName);
}
///
/// Creates a new
/// The expression to bind
/// A new expression binding with the specified expression and a generated variable name
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbExpressionBinding CreateExpressionBinding(DbExpression input)
{
return new DbExpressionBinding(this, input, this.BindingAliases.Next());
}
///
/// Creates a new
/// The expression to bind
/// The variable name that should be used for the binding
/// The variable name that should be used to refer to the group when the new group expression binding is used in a group-by expression
/// A new group expression binding with the specified expression, variable name and group variable name
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbGroupExpressionBinding CreateGroupExpressionBinding(DbExpression input, string varName, string groupVarName)
{
return new DbGroupExpressionBinding(this, input, varName, groupVarName);
}
///
/// Creates a new group expression binding that uses generated variable and group variable names to bind the given expression
///
/// The expression to bind
/// A new group expression binding with the specified expression and a generated variable name and group variable name
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbGroupExpressionBinding CreateGroupExpressionBinding(DbExpression input)
{
string alias = this.BindingAliases.Next();
return new DbGroupExpressionBinding(this, input, alias, string.Format(CultureInfo.InvariantCulture, "Group{0}", alias));
}
///
/// Creates a new
/// The expression that defines the sort key
/// Specifies whether the sort order is ascending (true) or descending (false)
/// A new sort clause with the given sort key and sort order
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbSortClause CreateSortClause(DbExpression key, bool ascending)
{
return new DbSortClause(key, ascending, String.Empty);
}
///
/// Creates a new
/// The expression that defines the sort key
/// Specifies whether the sort order is ascending (true) or descending (false)
/// The collation to sort under
/// A new sort clause with the given sort key, sort order and collation
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbSortClause CreateSortClause(DbExpression key, bool ascending, string collation)
{
EntityUtil.CheckArgumentNull(collation, "collation");
if (StringUtil.IsNullOrEmptyOrWhiteSpace(collation))
{
throw EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.Cqt_Sort_EmptyCollationInvalid, "collation");
}
return new DbSortClause(key, ascending, collation);
}
///
/// Creates a new
/// The function that defines the aggregate operation.
/// The argument over which the aggregate function should be calculated.
/// A new function aggregate with a reference to the given function and argument. The function aggregate's Distinct property will have the value false
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionAggregate CreateFunctionAggregate(EdmFunction function, DbExpression argument)
{
return new DbFunctionAggregate(this, function, argument, false);
}
///
/// Creates a new
/// The function that defines the aggregate operation.
/// The argument over which the aggregate function should be calculated.
/// A new function aggregate with a reference to the given function and argument. The function aggregate's Distinct property will have the value true
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionAggregate CreateDistinctFunctionAggregate(EdmFunction function, DbExpression argument)
{
return new DbFunctionAggregate(this, function, argument, true);
}
#if ENABLE_NESTAGGREGATE
///
/// Creates a new
/// The argument over which to perform the nest operation
/// A new nest aggregate with a reference to the given argument.
///
/// Creates a new
/// The relationship end from which navigation takes place
///The relationship end to which navigation may be satisifed using the target entity ref
///An expression that produces a reference to the target entity (and must therefore have a Ref result type)
internal DbRelatedEntityRef CreateRelatedEntityRef(RelationshipEndMember sourceEnd, RelationshipEndMember targetEnd, DbExpression targetEntity)
{
return new DbRelatedEntityRef(this, sourceEnd, targetEnd, targetEntity);
}
#endregion
#region DbExpression Factory Methods
#region Constants
///
/// Creates a new
/// The constant value to represent.
/// A new DbConstantExpression with the given value.
///
/// Creates a new
/// The constant value to represent.
/// The type of the constant value.
/// A new DbConstantExpression with the given value and a result type of
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbConstantExpression CreateConstantExpression(object value, TypeUsage constantType)
{
return new DbConstantExpression(this, value, constantType);
}
///
/// Creates a false.
///
/// A DbConstantExpression with the Boolean value false.
/*CQT_PUBLIC_API(*/internal/*)*/ DbConstantExpression CreateFalseExpression()
{
if (null == _falseExpr)
{
_falseExpr = this.CreateConstantExpression(false, this.TypeHelper.CreateBooleanResultType());
}
return _falseExpr;
}
///
/// Creates a new
/// The type of the null value.
/// An instance of DbNullExpression
///
/// Creates a
/// A DbConstantExpression with the Boolean value true.
/*CQT_PUBLIC_API(*/internal/*)*/ DbConstantExpression CreateTrueExpression()
{
if (null == _trueExpr)
{
_trueExpr = this.CreateConstantExpression(true, this.TypeHelper.CreateBooleanResultType());
}
return _trueExpr;
}
#endregion
#region Variables
///
/// Creates a
/// The name of the parameter to reference.
/// A new DbParameterReferenceExpression that references the given parameter.
/// If no parameter with the given name exists on the command tree. Parameters can be added to the command tree using the AddParameter method
/*CQT_PUBLIC_API(*/internal/*)*/ DbParameterReferenceExpression CreateParameterReferenceExpression(string name)
{
if (null == name)
{
throw EntityUtil.ArgumentNull("name");
}
//
// Attempt to find a parameter with the specified name in the parameters dictionary.
// If the name is not valid the dictionary is not consulted since no parameter with
// an invalid name should ever be added to the dictionary.
// Note that when the ParameterRefExpression is created the name that is used is the
// exact name that the parameter was originally created with (from the dictionary)
// since this is the name the Validator will use (in an exact match) to determine
// whether a given ParameterRefExpression is valid or not.
//
KeyValuePair foundParam;
if (DbCommandTree.IsValidParameterName(name) &&
_paramMappings.TryGetValue(name, out foundParam))
{
return new DbParameterReferenceExpression(this, foundParam.Value, foundParam.Key);
}
throw EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.Cqt_CommandTree_NoParameterExists, "name");
}
///
/// Creates a
/// The name of the variable to reference.
/// The type of the variable to reference.
/// A new DbVariableReferenceExpression that references the specified variable.
///
/// Creates a new
/// The metadata for the method to invoke.
/// The invocation target.
/// The arguments to the method.
/// A new MethodExpression that represents the method invocation.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ MethodExpression CreateInstanceMethodExpression(MethodMetadata methodInfo, Expression instance, IList args)
{
if (methodInfo != null && methodInfo.IsStatic)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_InstanceMethodRequired, "methodInfo");
}
return new MethodExpression(this, methodInfo, args, instance);
}
///
/// Creates a new
/// The metadata for the method to invoke.
/// The arguments to the method.
/// A new MethodExpression that represents the method invocation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ MethodExpression CreateStaticMethodExpression(MethodMetadata methodInfo, IList args)
{
if (methodInfo != null && !methodInfo.IsStatic)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_StaticMethodRequired, "methodInfo");
}
return new MethodExpression(this, methodInfo, args, null);
}
#endif
///
/// Creates a new
/// The name of the property to retrieve.
/// The instance from which to retrieve the property.
/// A new DbPropertyExpression that represents the property retrieval
/// No property with the specified name is declared by the type of
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(string propertyName, DbExpression instance)
{
return CreatePropertyExpression(propertyName, false, instance);
}
///
/// Creates a new
/// The name of the property to retrieve.
/// If true , a case-insensitive member lookup of A new DbPropertyExpression that represents the property retrieval
/// No property with the specified name (determined with respect to
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(string propertyName, bool ignoreCase, DbExpression instance)
{
EntityUtil.CheckArgumentNull(propertyName, "propertyName");
EntityUtil.CheckArgumentNull(instance, "instance");
//
// EdmProperty, NavigationProperty and RelationshipEndMember are the only valid members for DbPropertyExpression.
// Since these all derive from EdmMember they are declared by subtypes of StructuralType,
// so a non-StructuralType instance is invalid.
//
StructuralType structType;
if(TypeHelpers.TryGetEdmType(instance.ResultType, out structType))
{
//
// Does the type declare a member with the given name?
//
EdmMember foundMember;
if(structType.Members.TryGetValue(propertyName, ignoreCase, out foundMember))
{
//
// If the member is a RelationshipEndMember, call the corresponding overload.
//
if (Helper.IsRelationshipEndMember(foundMember))
{
return this.CreatePropertyExpression((RelationshipEndMember)foundMember, instance);
}
//
// Otherwise if the member is an EdmProperty, call that overload instead.
//
if (Helper.IsEdmProperty(foundMember))
{
return this.CreatePropertyExpression((EdmProperty)foundMember, instance);
}
//
// The only remaining valid option is NavigationProperty.
//
if (Helper.IsNavigationProperty(foundMember))
{
return this.CreatePropertyExpression((NavigationProperty)foundMember, instance);
}
}
}
throw EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.Cqt_Factory_NoSuchProperty, "propertyName");
}
///
/// Creates a new
/// Metadata for the property to retrieve.
/// The instance from which to retrieve the property. May be null if the property is static.
/// A new DbPropertyExpression representing the property retrieval.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(EdmProperty propertyInfo, DbExpression instance)
{
return new DbPropertyExpression(this, propertyInfo, instance);
}
///
/// Creates a new
/// Metadata for the relationship end member to retrieve.
/// The instance from which to retrieve the relationship end member.
/// A new DbPropertyExpression representing the relationship end member retrieval.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(RelationshipEndMember memberInfo, DbExpression instance)
{
return new DbPropertyExpression(this, memberInfo, instance);
}
///
/// Creates a new
/// Metadata for the navigation property to retrieve.
/// The instance from which to retrieve the navigation property.
/// A new DbPropertyExpression representing the navigation property retrieval.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(NavigationProperty propertyInfo, DbExpression instance)
{
return new DbPropertyExpression(this, propertyInfo, instance);
}
///
/// Creates a new
/// Metadata for the property that represents the end of the relationship from which navigation should occur
/// Metadata for the property that represents the end of the relationship to which navigation should occur
/// An expression the specifies the instance from which naviagtion should occur
/// A new DbRelationshipNavigationExpression representing the navigation of the specified from and to relation ends of the specified relation type from the specified navigation source instance
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbRelationshipNavigationExpression CreateRelationshipNavigationExpression(RelationshipEndMember fromEnd, RelationshipEndMember toEnd, DbExpression from)
{
return new DbRelationshipNavigationExpression(this, fromEnd, toEnd, from);
}
///
/// Creates a new
/// Metadata for the relation type that represents the relationship
/// The name of the property of the relation type that represents the end of the relationship from which navigation should occur
/// The name of the property of the relation type that represents the end of the relationship to which navigation should occur
/// An expression the specifies the instance from which naviagtion should occur
/// A new DbRelationshipNavigationExpression representing the navigation of the specified from and to relation ends of the specified relation type from the specified navigation source instance
///
///
///
///
///
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
/*CQT_PUBLIC_API(*/internal/*)*/ DbRelationshipNavigationExpression CreateRelationshipNavigationExpression(RelationshipType type, string fromEndName, string toEndName, DbExpression from)
{
return new DbRelationshipNavigationExpression(this, type, fromEndName, toEndName, from);
}
#endregion
#region EdmFunction Invocation (including Lambda)
///
/// Creates a new
/// Metadata for the function to invoke.
/// A list of expressions that provide the arguments to the function.
/// A new DbFunctionExpression representing the function invocation.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionExpression CreateFunctionExpression(EdmFunction function, IList args)
{
return new DbFunctionExpression(this, function, null, args);
}
///
/// Creates a
/// The names and types of the formal arguments to the Lambda function
/// An expression that defines the logic of the Lambda function
/// A list of expressions that provides the values on which the function is invoked.
/// A new DbFunctionExpression that invokes the specified Lambda function with the given arguments
///
/// , or
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionExpression CreateLambdaFunctionExpression(IEnumerable> formals, DbExpression body, IList args)
{
EntityUtil.CheckArgumentNull(formals, "formals");
EntityUtil.CheckArgumentNull(body, "body");
List funcParams = new List();
List> formalArgs = new List>(formals);
int idx = 0;
CommandTreeUtils.CheckNamedList(
"formals",
formalArgs,
true,
delegate(KeyValuePair formal, int index)
{
this.TypeHelper.CheckType(formal.Value, CommandTreeUtils.FormatIndex("formals", idx));
idx++;
funcParams.Add(new FunctionParameter(formal.Key, formal.Value, ParameterMode.In));
}
);
FunctionParameter retParam = new FunctionParameter("Return", body.ResultType, ParameterMode.ReturnValue);
EdmFunction lambdaFunction =
new EdmFunction(DbFunctionExpression.LambdaFunctionName,
DbFunctionExpression.LambdaFunctionNameSpace,
retParam.TypeUsage.EdmType.DataSpace,
new EdmFunctionPayload
{
ReturnParameter = retParam,
Parameters = funcParams.ToArray(),
});
lambdaFunction.SetReadOnly();
return new DbFunctionExpression(this, lambdaFunction, body, args);
}
#endregion
#region Arithmetic Operators
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the division operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateDivideExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Divide, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the subtraction operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateMinusExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Minus, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the modulo operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateModuloExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Modulo, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the multiplication operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateMultiplyExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Multiply, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the addition operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreatePlusExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Plus, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the argument.
/// A new DbArithmeticExpression representing the negation operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateUnaryMinusExpression(DbExpression argument)
{
return new DbArithmeticExpression(this, DbExpressionKind.UnaryMinus, CommandTreeUtils.CreateList(argument));
}
#endregion
#region Comparison Operators
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the equality comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateEqualsExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.Equals, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the greater-than comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateGreaterThanExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.GreaterThan, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the greater-than-or-equal-to comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateGreaterThanOrEqualsExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.GreaterThanOrEquals, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the less-than comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateLessThanExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.LessThan, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the less-than-or-equal-to comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateLessThanOrEqualsExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.LessThanOrEquals, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the inequality comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateNotEqualsExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.NotEquals, left, right);
}
#endregion
#region Boolean Connectors
///
/// Creates an
/// A Boolean expression that specifies the left argument.
/// A Boolean expression that specifies the right argument.
/// A new DbAndExpression with the specified arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbAndExpression CreateAndExpression(DbExpression left, DbExpression right)
{
return new DbAndExpression(this, left, right);
}
///
/// Creates an
/// A Boolean expression that specifies the left argument.
/// A Boolean expression that specifies the right argument.
/// A new DbOrExpression with the specified arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbOrExpression CreateOrExpression(DbExpression left, DbExpression right)
{
return new DbOrExpression(this, left, right);
}
///
/// Creates a
/// A Boolean expression that specifies the argument.
/// A new DbNotExpression with the specified argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbNotExpression CreateNotExpression(DbExpression argument)
{
return new DbNotExpression(this, argument);
}
#endregion
#region Relational Operators
///
/// Creates a new
/// An expression binding that specifies the input set.
/// An expression representing a predicate to evaluate for each member of the input set.
/// A new DbQuantifierExpression that represents the Any operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbQuantifierExpression CreateAnyExpression(DbExpressionBinding input, DbExpression predicate)
{
return new DbQuantifierExpression(this, DbExpressionKind.Any, input, predicate);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// An expression representing a predicate to evaluate for each member of the input set.
/// A new DbQuantifierExpression that represents the All operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbQuantifierExpression CreateAllExpression(DbExpressionBinding input, DbExpression predicate)
{
return new DbQuantifierExpression(this, DbExpressionKind.All, input, predicate);
}
///
/// Creates a new
/// An An new DbApplyExpression with the specified input and apply bindings and an
///
/// Creates a new null.
///
/// An An new DbApplyExpression with the specified input and apply bindings and an
///
/// Creates a new
/// An expression that defines the set over which to perfom the distinct operation.
/// A new DbDistinctExpression that represents the distinct operation applied to the specified set argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbDistinctExpression CreateDistinctExpression(DbExpression argument)
{
return new DbDistinctExpression(this, argument);
}
///
/// Creates a new
/// An expression that specifies the input set.
/// A DbElementExpression that represents the conversion of the single-member set argument to a singleton.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbElementExpression CreateElementExpression(DbExpression argument)
{
return new DbElementExpression(this, argument, false);
}
///
/// Creates a new
/// An expression that specifies the input set.
/// A DbElementExpression that represents the conversion of the single-member set argument to a singleton.
///
///
internal DbElementExpression CreateElementExpressionUnwrapSingleProperty(DbExpression argument)
{
return new DbElementExpression(this, argument, true);
}
///
/// Creates a new
/// An expression that defines the left set argument.
/// An expression that defines the right set argument.
/// A new DbExceptExpression that represents the difference of the left argument from the right argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbExceptExpression CreateExceptExpression(DbExpression left, DbExpression right)
{
return new DbExceptExpression(this, left, right);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// An expression representing a predicate to evaluate for each member of the input set.
/// A new DbFilterExpression that produces the filtered set.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFilterExpression CreateFilterExpression(DbExpressionBinding input, DbExpression predicate)
{
return new DbFilterExpression(this, input, predicate);
}
///
/// Creates a new
/// A A new DbGroupByExpression with the specified input set, grouping keys and aggregates.
///
///
///
///
///
/// DbGroupByExpression allows either the list of keys or the list of aggregates to be empty, but not both.
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbGroupByExpression CreateGroupByExpression(DbGroupExpressionBinding input, IList> keys, IList> aggregates)
{
return new DbGroupByExpression(this, input, keys, aggregates);
}
///
/// Creates a new
/// An expression that defines the left set argument.
/// An expression that defines the right set argument.
/// A new DbIntersectExpression that represents the intersection of the left and right arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbIntersectExpression CreateIntersectExpression(DbExpression left, DbExpression right)
{
return new DbIntersectExpression(this, left, right);
}
///
/// Creates a new
/// A list of expression bindings that specifies the input sets.
/// A new DbCrossJoinExpression, with an
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbCrossJoinExpression CreateCrossJoinExpression(IList inputs)
{
return new DbCrossJoinExpression(this, inputs);
}
///
/// Creates a new
/// An
/// A new DbJoinExpression, with an
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbJoinExpression CreateInnerJoinExpression(DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition)
{
return new DbJoinExpression(this, DbExpressionKind.InnerJoin, left, right, joinCondition);
}
///
/// Creates a new
/// An
/// A new DbJoinExpression, with an
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbJoinExpression CreateLeftOuterJoinExpression(DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition)
{
return new DbJoinExpression(this, DbExpressionKind.LeftOuterJoin, left, right, joinCondition);
}
///
/// Creates a new
/// An
/// A new DbJoinExpression, with an
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbJoinExpression CreateFullOuterJoinExpression(DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition)
{
return new DbJoinExpression(this, DbExpressionKind.FullOuterJoin, left, right, joinCondition);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// An expression to project over the set.
/// A new DbProjectExpression that represents the projection operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbProjectExpression CreateProjectExpression(DbExpressionBinding input, DbExpression projection)
{
return new DbProjectExpression(this, input, projection);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// A list of sort specifications that determine how the elements of the input set should be sorted.
/// An expression the specifies how many elements of the ordered set to skip.
/// A new DbSkipExpression that represents the skip operation.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbSkipExpression CreateSkipExpression(DbExpressionBinding input, IList sortOrder, DbExpression count)
{
return new DbSkipExpression(this, input, sortOrder, count);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// A list of sort specifications that determine how the elements of the input set should be sorted.
/// A new DbSortExpression that represents the sort operation.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbSortExpression CreateSortExpression(DbExpressionBinding input, IList sortOrder)
{
return new DbSortExpression(this, input, sortOrder);
}
///
/// Creates a new
/// An expression that defines the left set argument.
/// An expression that defines the right set argument.
/// A new DbUnionAllExpression that union, including duplicates, of the the left and right arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbUnionAllExpression CreateUnionAllExpression(DbExpression left, DbExpression right)
{
return new DbUnionAllExpression(this, left, right);
}
#endregion
#region General Operators
///
/// Creates a new
/// A list of expressions that provide the conditional for of each case.
/// A list of expressions that provide the result of each case.
/// An expression that defines the result when no case is matched.
/// A new DbCaseExpression with the specified cases and default result.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbCaseExpression CreateCaseExpression(IList whenExpressions, IList thenExpressions, DbExpression elseExpression)
{
return new DbCaseExpression(this, whenExpressions, thenExpressions, elseExpression);
}
///
/// Creates a new
/// The argument to which the cast should be applied.
/// Type metadata that specifies the type to cast to.
/// A new DbCastExpression with the specified argument and target type.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbCastExpression CreateCastExpression(DbExpression argument, TypeUsage toType)
{
return new DbCastExpression(this, toType, argument);
}
///
/// Creates a new
/// Metadata for the entity or relationship set to reference.
/// A new DbScanExpression based on the specified entity or relationship set.
///
/// Creates a new
/// An expression that specifies the input set
/// A new DbIsEmptyExpression with the specified argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbIsEmptyExpression CreateIsEmptyExpression(DbExpression argument)
{
return new DbIsEmptyExpression(this, argument);
}
///
/// Creates a new
/// An expression that specifies the argument.
/// A new DbIsNullExpression with the specified argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbIsNullExpression CreateIsNullExpression(DbExpression argument)
{
return new DbIsNullExpression(this, argument, false);
}
///
/// Creates a new
/// An expression that specifies the argument.
/// A new DbIsNullExpression with the specified argument.
///
///
internal DbIsNullExpression CreateIsNullExpressionAllowingRowTypeArgument(DbExpression argument)
{
return new DbIsNullExpression(this, argument, true);
}
///
/// Creates a new
/// An expression that specifies the instance.
/// Type metadata that specifies the type that the instance's result type should be compared to.
/// A new DbIsOfExpression with the specified instance and type and DbExpressionKind IsOf.
///
///
///
/// DbIsOfExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbIsOfExpression CreateIsOfExpression(DbExpression argument, TypeUsage type)
{
return new DbIsOfExpression(this, DbExpressionKind.IsOf, type, argument);
}
///
/// Creates a new
/// An expression that specifies the instance.
/// Type metadata that specifies the type that the instance's result type should be compared to.
/// A new DbIsOfExpression with the specified instance and type and DbExpressionKind IsOfOnly.
///
///
///
/// DbIsOfExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbIsOfExpression CreateIsOfOnlyExpression(DbExpression argument, TypeUsage type)
{
return new DbIsOfExpression(this, DbExpressionKind.IsOfOnly, type, argument);
}
///
/// Creates a new
/// An expression that specifies the input string.
/// An expression that specifies the pattern string.
/// A new DbLikeExpression with the specified input, pattern and a null escape.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbLikeExpression CreateLikeExpression(DbExpression input, DbExpression pattern)
{
return new DbLikeExpression(this, input, pattern, null);
}
///
/// Creates a new
/// An expression that specifies the input string.
/// An expression that specifies the pattern string.
/// An optional expression that specifies the escape string.
/// A new DbLikeExpression with the specified input, pattern and escape.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbLikeExpression CreateLikeExpression(DbExpression input, DbExpression pattern, DbExpression escape)
{
EntityUtil.CheckArgumentNull(escape, "escape");
return new DbLikeExpression(this, input, pattern, escape);
}
///
/// Creates a new
/// An expression that specifies the input collection.
/// An expression that specifies the limit value.
/// A new DbLimitExpression with the specified argument and limit values that does not include tied results.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbLimitExpression CreateLimitExpression(DbExpression argument, DbExpression limit)
{
return new DbLimitExpression(this, argument, limit, false);
}
///
/// Creates a new
/// An expression that specifies the input collection.
/// An expression that specifies the limit value.
/// A new DbLimitExpression with the specified argument and limit values that includes tied results.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbLimitExpression CreateLimitWithTiesExpression(DbExpression argument, DbExpression limit)
{
return new DbLimitExpression(this, argument, limit, true);
}
///
/// Creates a new
/// The type of the new instance.
/// Expressions that specify values of the new instances, interpreted according to the instance's type.
/// A new DbNewInstanceExpression with the specified type and arguments.
///
///
///
///
/// if
///
/// if
///
/// if
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbNewInstanceExpression CreateNewInstanceExpression(TypeUsage type, IList args)
{
return new DbNewInstanceExpression(this, type, args);
}
///
/// Creates a new
/// A list of string-DbExpression key-value pairs that defines the structure and values of the row.
/// A new DbNewInstanceExpression that represents the construction of the row.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbNewInstanceExpression CreateNewRowExpression(IList> recordColumns)
{
List args = new List();
List> colTypes = new List>();
CommandTreeUtils.CheckNamedList
(
"recordColumns",
recordColumns,
false, // Don't allow empty list
delegate(KeyValuePair exprInfo, int index)
{
// Use ExpressionLink for standard expression argument validation
ExpressionLink testLink = new ExpressionLink(CommandTreeUtils.FormatIndex("recordColumns", index), this, exprInfo.Value);
args.Add(exprInfo.Value);
colTypes.Add(new KeyValuePair(exprInfo.Key, exprInfo.Value.ResultType));
}
);
TypeUsage resultType = CommandTreeTypeHelper.CreateResultType(TypeHelpers.CreateRowType(colTypes));
return new DbNewInstanceExpression(this, resultType, args);
}
///
/// Creates a new
/// A list of expressions that provide the elements of the collection
/// A new DbNewInstanceExpression with the specified collection type and arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbNewInstanceExpression CreateNewCollectionExpression(IList collectionElements)
{
if (null == collectionElements)
{
throw EntityUtil.ArgumentNull("collectionElements");
}
if (collectionElements.Count < 1)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_NewCollectionElementsRequired, "collectionElements");
}
//
// Use an ExpressionList to determine the common element type of the collection
// (Note that this ExpressionList is not used by the DbNewInstanceExpression itself)
//
ExpressionList elements = new ExpressionList("collectionElements", this, collectionElements.Count);
elements.SetElements(collectionElements);
TypeUsage commonElementType = elements.GetCommonElementType();
if (TypeSemantics.IsNullOrNullType(commonElementType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_NewCollectionInvalidCommonType, "collectionElements");
}
TypeUsage resultType = CommandTreeTypeHelper.CreateCollectionResultType(commonElementType);
return new DbNewInstanceExpression(this, resultType, elements);
}
///
/// Creates a new
/// The type metadata for the collection to create
/// A new DbNewInstanceExpression with the specified collection type and an empty Arguments list.
///
/// Creates a new
/// The type of the Entity instance that is being constructed
/// Values for each (non-relationship) property of the Entity
/// A (possibly empty) list of A new DbNewInstanceExpression that represents the construction of the Entity, and includes the specified related Entity information in the see
internal DbNewInstanceExpression CreateNewEntityWithRelationshipsExpression(EntityType instanceType, IList attributeValues, IList relationships)
{
return new DbNewInstanceExpression(this, instanceType, attributeValues, relationships);
}
///
/// Creates a new
/// An A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of
///
///
///
/// DbOfTypeExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbOfTypeExpression CreateOfTypeExpression(DbExpression argument, TypeUsage ofType)
{
return new DbOfTypeExpression(this, DbExpressionKind.OfType, ofType, argument);
}
///
/// Creates a new
/// An A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of
///
///
///
/// DbOfTypeExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbOfTypeExpression CreateOfTypeOnlyExpression(DbExpression argument, TypeUsage ofType)
{
return new DbOfTypeExpression(this, DbExpressionKind.OfTypeOnly, ofType, argument);
}
///
/// Creates a new
/// The Entity set in which the referenced element resides.
/// An A new DbRefExpression that references the element with the specified key values in the given Entity set.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbRefExpression CreateRefExpression(EntitySet entitySet, DbExpression refKeys)
{
EntityUtil.CheckArgumentNull(entitySet, "entitySet");
return new DbRefExpression(this, entitySet, refKeys, entitySet.ElementType);
}
///
/// Creates a new
/// The Entity set in which the referenced element resides.
/// An A new DbRefExpression that references the element with the specified key values in the given Entity set.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbRefExpression CreateRefExpression(EntitySet entitySet, DbExpression refKeys, EntityType entityType)
{
return new DbRefExpression(this, entitySet, refKeys, entityType);
}
///
/// Creates a new
/// An A new DbDerefExpression that retrieves the specified Entity
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbDerefExpression CreateDerefExpression(DbExpression reference)
{
return new DbDerefExpression(this, reference);
}
///
/// Creates a new
/// The expression that provides the reference. This expression must have a reference Type with an Entity element type.
/// A new DbRefKeyExpression that retrieves the key values of the specified reference.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbRefKeyExpression CreateRefKeyExpression(DbExpression reference)
{
return new DbRefKeyExpression(this, reference);
}
///
/// Creates a new
/// The expression that provides the entity. This expression must have an entity result type.
/// A new DbEntityRefExpression that retrieves a reference to the specified entity.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbEntityRefExpression CreateEntityRefExpression(DbExpression entity)
{
return new DbEntityRefExpression(this, entity);
}
///
/// Creates a new
/// An expression that specifies the instance.
/// Type metadata for the treat-as type.
/// A new DbTreatExpression with the specified argument and type.
///
///
///
/// DbTreatExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbTreatExpression CreateTreatExpression(DbExpression argument, TypeUsage treatType)
{
return new DbTreatExpression(this, treatType, argument);
}
#endregion
//
// Additional expression builders
// ...
#endregion
#endregion
#region Internal Implementation
///
/// Gets the kind of this command tree.
///
internal abstract DbCommandTreeKind CommandTreeKind { get; }
///
/// Gets the metadata workspace used by this command tree.
///
internal MetadataWorkspace MetadataWorkspace { get { return _metadata; } }
///
/// Gets the data space in which metadata used by this command tree must reside.
///
internal DataSpace DataSpace { get { return _dataSpace; } }
internal CommandTreeTypeHelper TypeHelper { get { return _typeHelp; } }
internal virtual void Validate(System.Data.Common.CommandTrees.Internal.Validator v) { }
internal bool ValidationRequired
{
get
{
bool valReq = _validatedVersion < _currentVersion;
EntityBid.Trace(" %d#, %d{bool}\n", this.ObjectId, valReq);
return valReq;
}
}
internal void SetValid()
{
EntityBid.Trace(" %d#\n", this.ObjectId);
_validatedVersion = _currentVersion;
}
internal void SetModified()
{
int prev = _currentVersion;
if (int.MaxValue == _currentVersion)
{
_currentVersion = 1;
_validatedVersion = 0;
}
else
{
_currentVersion++;
}
EntityBid.Trace(" %d# previous version=%d, new version=%d\n", this.ObjectId, prev, _currentVersion);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] // we intend for this to be public someday; called from test code for now.
internal void ClearParameters()
{
EntityBid.Trace(" %d#\n", this.ObjectId);
_paramMappings.Clear();
}
internal void CopyParametersTo(DbCommandTree tree)
{
foreach (KeyValuePair paramInfo in _paramMappings.Values)
{
tree.AddParameter(paramInfo.Key, paramInfo.Value);
}
}
internal bool HasParameter(string parameterName, TypeUsage parameterType)
{
Debug.Assert(!string.IsNullOrEmpty(parameterName), "Parameter name should not be null or empty");
Debug.Assert(parameterType != null, "Parameter type should not be null");
KeyValuePair foundParam;
if(this._paramMappings.TryGetValue(parameterName, out foundParam))
{
return (foundParam.Key.Equals(parameterName, StringComparison.Ordinal) &&
// SQLBUDT#545720: Equivalence is not a sufficient check (consider row types for TVPs) - equality is required.
TypeSemantics.IsStructurallyEqualTo(foundParam.Value, parameterType));
}
return false;
}
#region Dump/Print Support
internal void Dump(ExpressionDumper dumper)
{
//
// Dump information about this command tree to the specified ExpressionDumper
//
// First dump standard information - the DataSpace of the command tree and its parameters
//
Dictionary attrs = new Dictionary();
attrs.Add("DataSpace", this.DataSpace);
dumper.Begin(this.GetType().Name, attrs);
//
// The name and type of each Parameter in turn is added to the output
//
dumper.Begin("Parameters", null);
foreach (KeyValuePair param in this.Parameters)
{
Dictionary paramAttrs = new Dictionary();
paramAttrs.Add("Name", param.Key);
dumper.Begin("Parameter", paramAttrs);
dumper.Dump(param.Value, "ParameterType");
dumper.End("Parameter");
}
dumper.End("Parameters");
//
// Delegate to the derived type's implementation that dumps the structure of the command tree
//
this.DumpStructure(dumper);
//
// Matching call to End to correspond with the call to Begin above
//
dumper.End(this.GetType().Name);
}
internal abstract void DumpStructure(ExpressionDumper dumper);
internal string DumpXml()
{
//
// This is a convenience method that dumps the command tree in an XML format.
// This is intended primarily as a debugging aid to allow inspection of the tree structure.
//
// Create a new MemoryStream that the XML dumper should write to.
//
MemoryStream stream = new MemoryStream();
//
// Create the dumper
//
XmlExpressionDumper dumper = new XmlExpressionDumper(stream);
//
// Dump this tree and then close the XML dumper so that the end document tag is written
// and the output is flushed to the stream.
//
this.Dump(dumper);
dumper.Close();
//
// Construct a string from the resulting memory stream and return it to the caller
//
return XmlExpressionDumper.DefaultEncoding.GetString(stream.ToArray());
}
internal string Print()
{
return this.PrintTree(new ExpressionPrinter());
}
internal abstract string PrintTree(ExpressionPrinter printer);
#endregion
#region DbExpression Replacement
internal void Replace(ReplacerCallback callback)
{
using (new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
ExpressionReplacer replacer = new ExpressionReplacer(callback);
this.Replace(replacer);
}
}
internal abstract void Replace(ExpressionReplacer replacer);
#endregion
#region Tracing
internal void Trace()
{
if (EntityBid.AdvancedOn)
{
EntityBid.PutStrChunked(this.DumpXml());
EntityBid.Trace("\n");
}
else if (EntityBid.TraceOn)
{
EntityBid.PutStrChunked(this.Print());
EntityBid.Trace("\n");
}
}
#endregion
#region Container Tracking
internal void TrackContainer(EntityContainer container)
{
using (new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
if (!_containers.Contains(container))
{
EntityBid.Trace(" %d#, Adding container to tracked containers list: '%ls'\n", this.ObjectId, container.Name);
_containers.Add(container);
}
}
}
#endregion
#region Internal Helper API
internal DbApplyExpression CreateApplyExpressionByKind(DbExpressionKind applyKind, DbExpressionBinding input, DbExpressionBinding apply)
{
Debug.Assert(DbExpressionKind.CrossApply == applyKind || DbExpressionKind.OuterApply == applyKind, "Invalid ApplyType");
switch(applyKind)
{
case DbExpressionKind.CrossApply:
return this.CreateCrossApplyExpression(input, apply);
case DbExpressionKind.OuterApply:
return this.CreateOuterApplyExpression(input, apply);
default:
throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)applyKind);
}
}
internal DbExpression CreateJoinExpressionByKind(DbExpressionKind joinKind, DbExpression joinCondition, DbExpressionBinding input1, DbExpressionBinding input2)
{
Debug.Assert(DbExpressionKind.CrossJoin == joinKind ||
DbExpressionKind.FullOuterJoin == joinKind ||
DbExpressionKind.InnerJoin == joinKind ||
DbExpressionKind.LeftOuterJoin == joinKind,
"Invalid DbExpressionKind for CreateJoinExpressionByKind");
if (DbExpressionKind.CrossJoin == joinKind)
{
Debug.Assert(null == joinCondition, "Condition should not be specified for CrossJoin");
return this.CreateCrossJoinExpression(new DbExpressionBinding[2] { input1, input2 });
}
else
{
Debug.Assert(joinCondition != null, "Condition must be specified for non-CrossJoin");
switch (joinKind)
{
case DbExpressionKind.InnerJoin:
return this.CreateInnerJoinExpression(input1, input2, joinCondition);
case DbExpressionKind.LeftOuterJoin:
return this.CreateLeftOuterJoinExpression(input1, input2, joinCondition);
case DbExpressionKind.FullOuterJoin:
return this.CreateFullOuterJoinExpression(input1, input2, joinCondition);
default:
throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)joinKind);
}
}
}
internal static bool IsValidParameterName(string name)
{
return (!StringUtil.IsNullOrEmptyOrWhiteSpace(name) &&
_paramNameRegex.IsMatch(name));
}
private static readonly Regex _paramNameRegex = new Regex("^([A-Za-z])([A-Za-z0-9_])*$");
#endregion
#endregion
}
///
/// Describes the different "kinds" (classes) of command trees.
///
internal enum DbCommandTreeKind
{
Query,
Update,
Insert,
Delete,
Function,
}
}
// 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.Collections.ObjectModel;
using System.Data.Common;
using System.Globalization;
using System.IO;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.Data.Common.Utils;
using System.Data.Metadata.Edm;
using System.Data.Common.CommandTrees.Internal;
namespace System.Data.Common.CommandTrees
{
///
/// DbCommandTree is the abstract base type for the Delete, Query, Insert and Update DbCommandTree types.
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
public abstract class DbCommandTree
{
#region Private Instance Fields
// Metadata collection
private MetadataWorkspace _metadata;
private DataSpace _dataSpace;
// Commonly used types
private CommandTreeTypeHelper _typeHelp;
// CreateParameter Support
private Dictionary> _paramMappings = new Dictionary>(StringComparer.OrdinalIgnoreCase);
// Pre-built Expressions
DbConstantExpression _trueExpr;
DbConstantExpression _falseExpr;
// Validation support
private int _currentVersion = 1;
private int _validatedVersion;
// Referenced Container Tracking
private List _containers = new List();
// Binding alias generation
private AliasGenerator _bindingAliases;
internal AliasGenerator BindingAliases
{
get
{
if (null == _bindingAliases)
{
_bindingAliases = new AliasGenerator(string.Format(CultureInfo.InvariantCulture, "Var_{0}_", this.ObjectId), 0);
}
return _bindingAliases;
}
}
private static int s_instanceCount; // Bid counter
internal readonly int ObjectId = System.Threading.Interlocked.Increment(ref s_instanceCount);
#endregion
#region Constructors
///
/// Initializes a new command tree with a given metadata workspace.
///
/// The metadata workspace against which the command tree should operate.
/// The logical 'space' that metadata in the expressions used in this command tree must belong to.
/// %d#", this.ObjectId))
{
if (null == metadata)
{
throw EntityUtil.ArgumentNull("metadata");
}
//
// Ensure that this is a valid value, in addition to non-null
//
if (!CommandTreeUtils.IsValidDataSpace(dataSpace))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_InvalidDataSpace, "dataSpace");
}
//
// Assign the metadata workspace and initalize commonly used types.
//
_metadata = new MetadataWorkspace();
ItemCollection objectItemCollection;
//While EdmItemCollection and StorageitemCollections are required
//ObjectItemCollection may or may not be registered on the workspace yet.
//So register the ObjectItemCollection if it exists.
if (metadata.TryGetItemCollection(DataSpace.OSpace, out objectItemCollection))
{
_metadata.RegisterItemCollection(objectItemCollection);
}
_metadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSpace));
_metadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSSpace));
_metadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.SSpace));
_dataSpace = dataSpace;
_typeHelp = new CommandTreeTypeHelper(this);
}
}
#endregion
#region Public API
///
/// Clones the specified
/// The expression to import
/// If the expression is already owned by this command tree, the original expression. Otherwise, a copy of the expression that is owned by this command tree
/// %d#", this.ObjectId))
{
EntityBid.Trace(" %d#, source=%d#, %d{cqt.DbExpressionKind}\n", this.ObjectId, DbExpression.GetObjectId(source), DbExpression.GetExpressionKind(source));
if (this == source.CommandTree)
{
return source;
}
// Command Trees should only ever exist in one Data Space, the C-Space.
//Debug.Assert(source.CommandTree.DataSpace == this.DataSpace, "DbCommandTree DataSpace mismatch");
return ExpressionCopier.Copy(this, source);
}
}
///
/// Verifies that the command tree is valid, including the validity of variable and parameter references.
///
/// If the command tree is invalid
/*CQT_PUBLIC_API(*/internal/*)*/ void Validate()
{
using(new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
if (!this.ValidationRequired)
{
return;
}
this.Validate(new System.Data.Common.CommandTrees.Internal.Validator());
this.SetValid();
}
}
///
/// Adds a parameter to the set of parameters that may be referenced within this command tree. If a parameter with the same name but a different type already exists on this command tree then an exception will be thrown.
///
/// The name of the new parameter
/// A description of the type of the new parameter
/// A parameter with the same name but a different type already exists on this command tree.
/*CQT_PUBLIC_API(*/internal/*)*/ void AddParameter(string name, TypeUsage type)
{
EntityUtil.CheckArgumentNull(name, "name");
this.TypeHelper.CheckType(type);
using(new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
EntityBid.Trace(" %d#, name='%ls'\n", this.ObjectId, name);
EntityBid.Trace(" %d#, type='%ls'\n", this.ObjectId, TypeHelpers.GetStrongName(type));
if (!DbCommandTree.IsValidParameterName(name))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_InvalidParameterName(name), "name");
}
KeyValuePair foundParam;
if (_paramMappings.TryGetValue(name, out foundParam))
{
// SQLBUDT#545720: Equivalence is not a sufficient check (consider row types for TVPs) - equality is required.
if (!TypeSemantics.IsStructurallyEqualTo(type, foundParam.Value))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_ParameterExists, "type");
}
}
else
{
_paramMappings.Add(name, new KeyValuePair(name, type));
}
}
}
///
/// Gets the name and corresponding type of each parameter that can be referenced within this command tree.
///
public IEnumerable> Parameters
{
get
{
using(new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
Dictionary retParams = new Dictionary();
foreach (KeyValuePair definedParam in _paramMappings.Values)
{
EntityBid.Trace(" %d#, name='%ls'\n", this.ObjectId, definedParam.Key);
EntityBid.Trace(" %d#, type='%ls'\n", this.ObjectId, TypeHelpers.GetStrongName(definedParam.Value));
retParams.Add(definedParam.Key, definedParam.Value);
}
return retParams;
}
}
}
// VersionNumber need only be public when Command Trees are mutable.
#if PUBLIC_COMMANDTREE_VERSIONNUMBER
///
/// Gets the current version of this DbCommandTree.
///
public int VersionNumber { get { return _currentVersion; } }
#endif
#region Non-DbExpression Factory Methods
///
/// Creates a new
/// The expression to bind
/// The variable name that should be used for the binding
/// A new expression binding with the specified expression and variable name
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbExpressionBinding CreateExpressionBinding(DbExpression input, string varName)
{
return new DbExpressionBinding(this, input, varName);
}
///
/// Creates a new
/// The expression to bind
/// A new expression binding with the specified expression and a generated variable name
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbExpressionBinding CreateExpressionBinding(DbExpression input)
{
return new DbExpressionBinding(this, input, this.BindingAliases.Next());
}
///
/// Creates a new
/// The expression to bind
/// The variable name that should be used for the binding
/// The variable name that should be used to refer to the group when the new group expression binding is used in a group-by expression
/// A new group expression binding with the specified expression, variable name and group variable name
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbGroupExpressionBinding CreateGroupExpressionBinding(DbExpression input, string varName, string groupVarName)
{
return new DbGroupExpressionBinding(this, input, varName, groupVarName);
}
///
/// Creates a new group expression binding that uses generated variable and group variable names to bind the given expression
///
/// The expression to bind
/// A new group expression binding with the specified expression and a generated variable name and group variable name
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbGroupExpressionBinding CreateGroupExpressionBinding(DbExpression input)
{
string alias = this.BindingAliases.Next();
return new DbGroupExpressionBinding(this, input, alias, string.Format(CultureInfo.InvariantCulture, "Group{0}", alias));
}
///
/// Creates a new
/// The expression that defines the sort key
/// Specifies whether the sort order is ascending (true) or descending (false)
/// A new sort clause with the given sort key and sort order
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbSortClause CreateSortClause(DbExpression key, bool ascending)
{
return new DbSortClause(key, ascending, String.Empty);
}
///
/// Creates a new
/// The expression that defines the sort key
/// Specifies whether the sort order is ascending (true) or descending (false)
/// The collation to sort under
/// A new sort clause with the given sort key, sort order and collation
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbSortClause CreateSortClause(DbExpression key, bool ascending, string collation)
{
EntityUtil.CheckArgumentNull(collation, "collation");
if (StringUtil.IsNullOrEmptyOrWhiteSpace(collation))
{
throw EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.Cqt_Sort_EmptyCollationInvalid, "collation");
}
return new DbSortClause(key, ascending, collation);
}
///
/// Creates a new
/// The function that defines the aggregate operation.
/// The argument over which the aggregate function should be calculated.
/// A new function aggregate with a reference to the given function and argument. The function aggregate's Distinct property will have the value false
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionAggregate CreateFunctionAggregate(EdmFunction function, DbExpression argument)
{
return new DbFunctionAggregate(this, function, argument, false);
}
///
/// Creates a new
/// The function that defines the aggregate operation.
/// The argument over which the aggregate function should be calculated.
/// A new function aggregate with a reference to the given function and argument. The function aggregate's Distinct property will have the value true
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionAggregate CreateDistinctFunctionAggregate(EdmFunction function, DbExpression argument)
{
return new DbFunctionAggregate(this, function, argument, true);
}
#if ENABLE_NESTAGGREGATE
///
/// Creates a new
/// The argument over which to perform the nest operation
/// A new nest aggregate with a reference to the given argument.
///
/// Creates a new
/// The relationship end from which navigation takes place
///The relationship end to which navigation may be satisifed using the target entity ref
///An expression that produces a reference to the target entity (and must therefore have a Ref result type)
internal DbRelatedEntityRef CreateRelatedEntityRef(RelationshipEndMember sourceEnd, RelationshipEndMember targetEnd, DbExpression targetEntity)
{
return new DbRelatedEntityRef(this, sourceEnd, targetEnd, targetEntity);
}
#endregion
#region DbExpression Factory Methods
#region Constants
///
/// Creates a new
/// The constant value to represent.
/// A new DbConstantExpression with the given value.
///
/// Creates a new
/// The constant value to represent.
/// The type of the constant value.
/// A new DbConstantExpression with the given value and a result type of
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbConstantExpression CreateConstantExpression(object value, TypeUsage constantType)
{
return new DbConstantExpression(this, value, constantType);
}
///
/// Creates a false.
///
/// A DbConstantExpression with the Boolean value false.
/*CQT_PUBLIC_API(*/internal/*)*/ DbConstantExpression CreateFalseExpression()
{
if (null == _falseExpr)
{
_falseExpr = this.CreateConstantExpression(false, this.TypeHelper.CreateBooleanResultType());
}
return _falseExpr;
}
///
/// Creates a new
/// The type of the null value.
/// An instance of DbNullExpression
///
/// Creates a
/// A DbConstantExpression with the Boolean value true.
/*CQT_PUBLIC_API(*/internal/*)*/ DbConstantExpression CreateTrueExpression()
{
if (null == _trueExpr)
{
_trueExpr = this.CreateConstantExpression(true, this.TypeHelper.CreateBooleanResultType());
}
return _trueExpr;
}
#endregion
#region Variables
///
/// Creates a
/// The name of the parameter to reference.
/// A new DbParameterReferenceExpression that references the given parameter.
/// If no parameter with the given name exists on the command tree. Parameters can be added to the command tree using the AddParameter method
/*CQT_PUBLIC_API(*/internal/*)*/ DbParameterReferenceExpression CreateParameterReferenceExpression(string name)
{
if (null == name)
{
throw EntityUtil.ArgumentNull("name");
}
//
// Attempt to find a parameter with the specified name in the parameters dictionary.
// If the name is not valid the dictionary is not consulted since no parameter with
// an invalid name should ever be added to the dictionary.
// Note that when the ParameterRefExpression is created the name that is used is the
// exact name that the parameter was originally created with (from the dictionary)
// since this is the name the Validator will use (in an exact match) to determine
// whether a given ParameterRefExpression is valid or not.
//
KeyValuePair foundParam;
if (DbCommandTree.IsValidParameterName(name) &&
_paramMappings.TryGetValue(name, out foundParam))
{
return new DbParameterReferenceExpression(this, foundParam.Value, foundParam.Key);
}
throw EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.Cqt_CommandTree_NoParameterExists, "name");
}
///
/// Creates a
/// The name of the variable to reference.
/// The type of the variable to reference.
/// A new DbVariableReferenceExpression that references the specified variable.
///
/// Creates a new
/// The metadata for the method to invoke.
/// The invocation target.
/// The arguments to the method.
/// A new MethodExpression that represents the method invocation.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ MethodExpression CreateInstanceMethodExpression(MethodMetadata methodInfo, Expression instance, IList args)
{
if (methodInfo != null && methodInfo.IsStatic)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_InstanceMethodRequired, "methodInfo");
}
return new MethodExpression(this, methodInfo, args, instance);
}
///
/// Creates a new
/// The metadata for the method to invoke.
/// The arguments to the method.
/// A new MethodExpression that represents the method invocation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ MethodExpression CreateStaticMethodExpression(MethodMetadata methodInfo, IList args)
{
if (methodInfo != null && !methodInfo.IsStatic)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_StaticMethodRequired, "methodInfo");
}
return new MethodExpression(this, methodInfo, args, null);
}
#endif
///
/// Creates a new
/// The name of the property to retrieve.
/// The instance from which to retrieve the property.
/// A new DbPropertyExpression that represents the property retrieval
/// No property with the specified name is declared by the type of
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(string propertyName, DbExpression instance)
{
return CreatePropertyExpression(propertyName, false, instance);
}
///
/// Creates a new
/// The name of the property to retrieve.
/// If true , a case-insensitive member lookup of A new DbPropertyExpression that represents the property retrieval
/// No property with the specified name (determined with respect to
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(string propertyName, bool ignoreCase, DbExpression instance)
{
EntityUtil.CheckArgumentNull(propertyName, "propertyName");
EntityUtil.CheckArgumentNull(instance, "instance");
//
// EdmProperty, NavigationProperty and RelationshipEndMember are the only valid members for DbPropertyExpression.
// Since these all derive from EdmMember they are declared by subtypes of StructuralType,
// so a non-StructuralType instance is invalid.
//
StructuralType structType;
if(TypeHelpers.TryGetEdmType(instance.ResultType, out structType))
{
//
// Does the type declare a member with the given name?
//
EdmMember foundMember;
if(structType.Members.TryGetValue(propertyName, ignoreCase, out foundMember))
{
//
// If the member is a RelationshipEndMember, call the corresponding overload.
//
if (Helper.IsRelationshipEndMember(foundMember))
{
return this.CreatePropertyExpression((RelationshipEndMember)foundMember, instance);
}
//
// Otherwise if the member is an EdmProperty, call that overload instead.
//
if (Helper.IsEdmProperty(foundMember))
{
return this.CreatePropertyExpression((EdmProperty)foundMember, instance);
}
//
// The only remaining valid option is NavigationProperty.
//
if (Helper.IsNavigationProperty(foundMember))
{
return this.CreatePropertyExpression((NavigationProperty)foundMember, instance);
}
}
}
throw EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.Cqt_Factory_NoSuchProperty, "propertyName");
}
///
/// Creates a new
/// Metadata for the property to retrieve.
/// The instance from which to retrieve the property. May be null if the property is static.
/// A new DbPropertyExpression representing the property retrieval.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(EdmProperty propertyInfo, DbExpression instance)
{
return new DbPropertyExpression(this, propertyInfo, instance);
}
///
/// Creates a new
/// Metadata for the relationship end member to retrieve.
/// The instance from which to retrieve the relationship end member.
/// A new DbPropertyExpression representing the relationship end member retrieval.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(RelationshipEndMember memberInfo, DbExpression instance)
{
return new DbPropertyExpression(this, memberInfo, instance);
}
///
/// Creates a new
/// Metadata for the navigation property to retrieve.
/// The instance from which to retrieve the navigation property.
/// A new DbPropertyExpression representing the navigation property retrieval.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbPropertyExpression CreatePropertyExpression(NavigationProperty propertyInfo, DbExpression instance)
{
return new DbPropertyExpression(this, propertyInfo, instance);
}
///
/// Creates a new
/// Metadata for the property that represents the end of the relationship from which navigation should occur
/// Metadata for the property that represents the end of the relationship to which navigation should occur
/// An expression the specifies the instance from which naviagtion should occur
/// A new DbRelationshipNavigationExpression representing the navigation of the specified from and to relation ends of the specified relation type from the specified navigation source instance
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbRelationshipNavigationExpression CreateRelationshipNavigationExpression(RelationshipEndMember fromEnd, RelationshipEndMember toEnd, DbExpression from)
{
return new DbRelationshipNavigationExpression(this, fromEnd, toEnd, from);
}
///
/// Creates a new
/// Metadata for the relation type that represents the relationship
/// The name of the property of the relation type that represents the end of the relationship from which navigation should occur
/// The name of the property of the relation type that represents the end of the relationship to which navigation should occur
/// An expression the specifies the instance from which naviagtion should occur
/// A new DbRelationshipNavigationExpression representing the navigation of the specified from and to relation ends of the specified relation type from the specified navigation source instance
///
///
///
///
///
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
/*CQT_PUBLIC_API(*/internal/*)*/ DbRelationshipNavigationExpression CreateRelationshipNavigationExpression(RelationshipType type, string fromEndName, string toEndName, DbExpression from)
{
return new DbRelationshipNavigationExpression(this, type, fromEndName, toEndName, from);
}
#endregion
#region EdmFunction Invocation (including Lambda)
///
/// Creates a new
/// Metadata for the function to invoke.
/// A list of expressions that provide the arguments to the function.
/// A new DbFunctionExpression representing the function invocation.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionExpression CreateFunctionExpression(EdmFunction function, IList args)
{
return new DbFunctionExpression(this, function, null, args);
}
///
/// Creates a
/// The names and types of the formal arguments to the Lambda function
/// An expression that defines the logic of the Lambda function
/// A list of expressions that provides the values on which the function is invoked.
/// A new DbFunctionExpression that invokes the specified Lambda function with the given arguments
///
/// , or
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionExpression CreateLambdaFunctionExpression(IEnumerable> formals, DbExpression body, IList args)
{
EntityUtil.CheckArgumentNull(formals, "formals");
EntityUtil.CheckArgumentNull(body, "body");
List funcParams = new List();
List> formalArgs = new List>(formals);
int idx = 0;
CommandTreeUtils.CheckNamedList(
"formals",
formalArgs,
true,
delegate(KeyValuePair formal, int index)
{
this.TypeHelper.CheckType(formal.Value, CommandTreeUtils.FormatIndex("formals", idx));
idx++;
funcParams.Add(new FunctionParameter(formal.Key, formal.Value, ParameterMode.In));
}
);
FunctionParameter retParam = new FunctionParameter("Return", body.ResultType, ParameterMode.ReturnValue);
EdmFunction lambdaFunction =
new EdmFunction(DbFunctionExpression.LambdaFunctionName,
DbFunctionExpression.LambdaFunctionNameSpace,
retParam.TypeUsage.EdmType.DataSpace,
new EdmFunctionPayload
{
ReturnParameter = retParam,
Parameters = funcParams.ToArray(),
});
lambdaFunction.SetReadOnly();
return new DbFunctionExpression(this, lambdaFunction, body, args);
}
#endregion
#region Arithmetic Operators
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the division operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateDivideExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Divide, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the subtraction operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateMinusExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Minus, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the modulo operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateModuloExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Modulo, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the multiplication operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateMultiplyExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Multiply, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbArithmeticExpression representing the addition operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreatePlusExpression(DbExpression left, DbExpression right)
{
return new DbArithmeticExpression(this, DbExpressionKind.Plus, CommandTreeUtils.CreateList(left, right));
}
///
/// Creates a new
/// An expression that specifies the argument.
/// A new DbArithmeticExpression representing the negation operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbArithmeticExpression CreateUnaryMinusExpression(DbExpression argument)
{
return new DbArithmeticExpression(this, DbExpressionKind.UnaryMinus, CommandTreeUtils.CreateList(argument));
}
#endregion
#region Comparison Operators
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the equality comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateEqualsExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.Equals, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the greater-than comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateGreaterThanExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.GreaterThan, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the greater-than-or-equal-to comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateGreaterThanOrEqualsExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.GreaterThanOrEquals, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the less-than comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateLessThanExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.LessThan, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the less-than-or-equal-to comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateLessThanOrEqualsExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.LessThanOrEquals, left, right);
}
///
/// Creates a new
/// An expression that specifies the left argument.
/// An expression that specifies the right argument.
/// A new DbComparisonExpression representing the inequality comparison.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbComparisonExpression CreateNotEqualsExpression(DbExpression left, DbExpression right)
{
return new DbComparisonExpression(this, DbExpressionKind.NotEquals, left, right);
}
#endregion
#region Boolean Connectors
///
/// Creates an
/// A Boolean expression that specifies the left argument.
/// A Boolean expression that specifies the right argument.
/// A new DbAndExpression with the specified arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbAndExpression CreateAndExpression(DbExpression left, DbExpression right)
{
return new DbAndExpression(this, left, right);
}
///
/// Creates an
/// A Boolean expression that specifies the left argument.
/// A Boolean expression that specifies the right argument.
/// A new DbOrExpression with the specified arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbOrExpression CreateOrExpression(DbExpression left, DbExpression right)
{
return new DbOrExpression(this, left, right);
}
///
/// Creates a
/// A Boolean expression that specifies the argument.
/// A new DbNotExpression with the specified argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbNotExpression CreateNotExpression(DbExpression argument)
{
return new DbNotExpression(this, argument);
}
#endregion
#region Relational Operators
///
/// Creates a new
/// An expression binding that specifies the input set.
/// An expression representing a predicate to evaluate for each member of the input set.
/// A new DbQuantifierExpression that represents the Any operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbQuantifierExpression CreateAnyExpression(DbExpressionBinding input, DbExpression predicate)
{
return new DbQuantifierExpression(this, DbExpressionKind.Any, input, predicate);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// An expression representing a predicate to evaluate for each member of the input set.
/// A new DbQuantifierExpression that represents the All operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbQuantifierExpression CreateAllExpression(DbExpressionBinding input, DbExpression predicate)
{
return new DbQuantifierExpression(this, DbExpressionKind.All, input, predicate);
}
///
/// Creates a new
/// An An new DbApplyExpression with the specified input and apply bindings and an
///
/// Creates a new null.
///
/// An An new DbApplyExpression with the specified input and apply bindings and an
///
/// Creates a new
/// An expression that defines the set over which to perfom the distinct operation.
/// A new DbDistinctExpression that represents the distinct operation applied to the specified set argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbDistinctExpression CreateDistinctExpression(DbExpression argument)
{
return new DbDistinctExpression(this, argument);
}
///
/// Creates a new
/// An expression that specifies the input set.
/// A DbElementExpression that represents the conversion of the single-member set argument to a singleton.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbElementExpression CreateElementExpression(DbExpression argument)
{
return new DbElementExpression(this, argument, false);
}
///
/// Creates a new
/// An expression that specifies the input set.
/// A DbElementExpression that represents the conversion of the single-member set argument to a singleton.
///
///
internal DbElementExpression CreateElementExpressionUnwrapSingleProperty(DbExpression argument)
{
return new DbElementExpression(this, argument, true);
}
///
/// Creates a new
/// An expression that defines the left set argument.
/// An expression that defines the right set argument.
/// A new DbExceptExpression that represents the difference of the left argument from the right argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbExceptExpression CreateExceptExpression(DbExpression left, DbExpression right)
{
return new DbExceptExpression(this, left, right);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// An expression representing a predicate to evaluate for each member of the input set.
/// A new DbFilterExpression that produces the filtered set.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbFilterExpression CreateFilterExpression(DbExpressionBinding input, DbExpression predicate)
{
return new DbFilterExpression(this, input, predicate);
}
///
/// Creates a new
/// A A new DbGroupByExpression with the specified input set, grouping keys and aggregates.
///
///
///
///
///
/// DbGroupByExpression allows either the list of keys or the list of aggregates to be empty, but not both.
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbGroupByExpression CreateGroupByExpression(DbGroupExpressionBinding input, IList> keys, IList> aggregates)
{
return new DbGroupByExpression(this, input, keys, aggregates);
}
///
/// Creates a new
/// An expression that defines the left set argument.
/// An expression that defines the right set argument.
/// A new DbIntersectExpression that represents the intersection of the left and right arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbIntersectExpression CreateIntersectExpression(DbExpression left, DbExpression right)
{
return new DbIntersectExpression(this, left, right);
}
///
/// Creates a new
/// A list of expression bindings that specifies the input sets.
/// A new DbCrossJoinExpression, with an
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbCrossJoinExpression CreateCrossJoinExpression(IList inputs)
{
return new DbCrossJoinExpression(this, inputs);
}
///
/// Creates a new
/// An
/// A new DbJoinExpression, with an
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbJoinExpression CreateInnerJoinExpression(DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition)
{
return new DbJoinExpression(this, DbExpressionKind.InnerJoin, left, right, joinCondition);
}
///
/// Creates a new
/// An
/// A new DbJoinExpression, with an
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbJoinExpression CreateLeftOuterJoinExpression(DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition)
{
return new DbJoinExpression(this, DbExpressionKind.LeftOuterJoin, left, right, joinCondition);
}
///
/// Creates a new
/// An
/// A new DbJoinExpression, with an
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbJoinExpression CreateFullOuterJoinExpression(DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition)
{
return new DbJoinExpression(this, DbExpressionKind.FullOuterJoin, left, right, joinCondition);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// An expression to project over the set.
/// A new DbProjectExpression that represents the projection operation.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbProjectExpression CreateProjectExpression(DbExpressionBinding input, DbExpression projection)
{
return new DbProjectExpression(this, input, projection);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// A list of sort specifications that determine how the elements of the input set should be sorted.
/// An expression the specifies how many elements of the ordered set to skip.
/// A new DbSkipExpression that represents the skip operation.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbSkipExpression CreateSkipExpression(DbExpressionBinding input, IList sortOrder, DbExpression count)
{
return new DbSkipExpression(this, input, sortOrder, count);
}
///
/// Creates a new
/// An expression binding that specifies the input set.
/// A list of sort specifications that determine how the elements of the input set should be sorted.
/// A new DbSortExpression that represents the sort operation.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbSortExpression CreateSortExpression(DbExpressionBinding input, IList sortOrder)
{
return new DbSortExpression(this, input, sortOrder);
}
///
/// Creates a new
/// An expression that defines the left set argument.
/// An expression that defines the right set argument.
/// A new DbUnionAllExpression that union, including duplicates, of the the left and right arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbUnionAllExpression CreateUnionAllExpression(DbExpression left, DbExpression right)
{
return new DbUnionAllExpression(this, left, right);
}
#endregion
#region General Operators
///
/// Creates a new
/// A list of expressions that provide the conditional for of each case.
/// A list of expressions that provide the result of each case.
/// An expression that defines the result when no case is matched.
/// A new DbCaseExpression with the specified cases and default result.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbCaseExpression CreateCaseExpression(IList whenExpressions, IList thenExpressions, DbExpression elseExpression)
{
return new DbCaseExpression(this, whenExpressions, thenExpressions, elseExpression);
}
///
/// Creates a new
/// The argument to which the cast should be applied.
/// Type metadata that specifies the type to cast to.
/// A new DbCastExpression with the specified argument and target type.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbCastExpression CreateCastExpression(DbExpression argument, TypeUsage toType)
{
return new DbCastExpression(this, toType, argument);
}
///
/// Creates a new
/// Metadata for the entity or relationship set to reference.
/// A new DbScanExpression based on the specified entity or relationship set.
///
/// Creates a new
/// An expression that specifies the input set
/// A new DbIsEmptyExpression with the specified argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbIsEmptyExpression CreateIsEmptyExpression(DbExpression argument)
{
return new DbIsEmptyExpression(this, argument);
}
///
/// Creates a new
/// An expression that specifies the argument.
/// A new DbIsNullExpression with the specified argument.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbIsNullExpression CreateIsNullExpression(DbExpression argument)
{
return new DbIsNullExpression(this, argument, false);
}
///
/// Creates a new
/// An expression that specifies the argument.
/// A new DbIsNullExpression with the specified argument.
///
///
internal DbIsNullExpression CreateIsNullExpressionAllowingRowTypeArgument(DbExpression argument)
{
return new DbIsNullExpression(this, argument, true);
}
///
/// Creates a new
/// An expression that specifies the instance.
/// Type metadata that specifies the type that the instance's result type should be compared to.
/// A new DbIsOfExpression with the specified instance and type and DbExpressionKind IsOf.
///
///
///
/// DbIsOfExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbIsOfExpression CreateIsOfExpression(DbExpression argument, TypeUsage type)
{
return new DbIsOfExpression(this, DbExpressionKind.IsOf, type, argument);
}
///
/// Creates a new
/// An expression that specifies the instance.
/// Type metadata that specifies the type that the instance's result type should be compared to.
/// A new DbIsOfExpression with the specified instance and type and DbExpressionKind IsOfOnly.
///
///
///
/// DbIsOfExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbIsOfExpression CreateIsOfOnlyExpression(DbExpression argument, TypeUsage type)
{
return new DbIsOfExpression(this, DbExpressionKind.IsOfOnly, type, argument);
}
///
/// Creates a new
/// An expression that specifies the input string.
/// An expression that specifies the pattern string.
/// A new DbLikeExpression with the specified input, pattern and a null escape.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbLikeExpression CreateLikeExpression(DbExpression input, DbExpression pattern)
{
return new DbLikeExpression(this, input, pattern, null);
}
///
/// Creates a new
/// An expression that specifies the input string.
/// An expression that specifies the pattern string.
/// An optional expression that specifies the escape string.
/// A new DbLikeExpression with the specified input, pattern and escape.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbLikeExpression CreateLikeExpression(DbExpression input, DbExpression pattern, DbExpression escape)
{
EntityUtil.CheckArgumentNull(escape, "escape");
return new DbLikeExpression(this, input, pattern, escape);
}
///
/// Creates a new
/// An expression that specifies the input collection.
/// An expression that specifies the limit value.
/// A new DbLimitExpression with the specified argument and limit values that does not include tied results.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbLimitExpression CreateLimitExpression(DbExpression argument, DbExpression limit)
{
return new DbLimitExpression(this, argument, limit, false);
}
///
/// Creates a new
/// An expression that specifies the input collection.
/// An expression that specifies the limit value.
/// A new DbLimitExpression with the specified argument and limit values that includes tied results.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbLimitExpression CreateLimitWithTiesExpression(DbExpression argument, DbExpression limit)
{
return new DbLimitExpression(this, argument, limit, true);
}
///
/// Creates a new
/// The type of the new instance.
/// Expressions that specify values of the new instances, interpreted according to the instance's type.
/// A new DbNewInstanceExpression with the specified type and arguments.
///
///
///
///
/// if
///
/// if
///
/// if
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbNewInstanceExpression CreateNewInstanceExpression(TypeUsage type, IList args)
{
return new DbNewInstanceExpression(this, type, args);
}
///
/// Creates a new
/// A list of string-DbExpression key-value pairs that defines the structure and values of the row.
/// A new DbNewInstanceExpression that represents the construction of the row.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbNewInstanceExpression CreateNewRowExpression(IList> recordColumns)
{
List args = new List();
List> colTypes = new List>();
CommandTreeUtils.CheckNamedList
(
"recordColumns",
recordColumns,
false, // Don't allow empty list
delegate(KeyValuePair exprInfo, int index)
{
// Use ExpressionLink for standard expression argument validation
ExpressionLink testLink = new ExpressionLink(CommandTreeUtils.FormatIndex("recordColumns", index), this, exprInfo.Value);
args.Add(exprInfo.Value);
colTypes.Add(new KeyValuePair(exprInfo.Key, exprInfo.Value.ResultType));
}
);
TypeUsage resultType = CommandTreeTypeHelper.CreateResultType(TypeHelpers.CreateRowType(colTypes));
return new DbNewInstanceExpression(this, resultType, args);
}
///
/// Creates a new
/// A list of expressions that provide the elements of the collection
/// A new DbNewInstanceExpression with the specified collection type and arguments.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbNewInstanceExpression CreateNewCollectionExpression(IList collectionElements)
{
if (null == collectionElements)
{
throw EntityUtil.ArgumentNull("collectionElements");
}
if (collectionElements.Count < 1)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_NewCollectionElementsRequired, "collectionElements");
}
//
// Use an ExpressionList to determine the common element type of the collection
// (Note that this ExpressionList is not used by the DbNewInstanceExpression itself)
//
ExpressionList elements = new ExpressionList("collectionElements", this, collectionElements.Count);
elements.SetElements(collectionElements);
TypeUsage commonElementType = elements.GetCommonElementType();
if (TypeSemantics.IsNullOrNullType(commonElementType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_NewCollectionInvalidCommonType, "collectionElements");
}
TypeUsage resultType = CommandTreeTypeHelper.CreateCollectionResultType(commonElementType);
return new DbNewInstanceExpression(this, resultType, elements);
}
///
/// Creates a new
/// The type metadata for the collection to create
/// A new DbNewInstanceExpression with the specified collection type and an empty Arguments list.
///
/// Creates a new
/// The type of the Entity instance that is being constructed
/// Values for each (non-relationship) property of the Entity
/// A (possibly empty) list of A new DbNewInstanceExpression that represents the construction of the Entity, and includes the specified related Entity information in the see
internal DbNewInstanceExpression CreateNewEntityWithRelationshipsExpression(EntityType instanceType, IList attributeValues, IList relationships)
{
return new DbNewInstanceExpression(this, instanceType, attributeValues, relationships);
}
///
/// Creates a new
/// An A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of
///
///
///
/// DbOfTypeExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbOfTypeExpression CreateOfTypeExpression(DbExpression argument, TypeUsage ofType)
{
return new DbOfTypeExpression(this, DbExpressionKind.OfType, ofType, argument);
}
///
/// Creates a new
/// An A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of
///
///
///
/// DbOfTypeExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbOfTypeExpression CreateOfTypeOnlyExpression(DbExpression argument, TypeUsage ofType)
{
return new DbOfTypeExpression(this, DbExpressionKind.OfTypeOnly, ofType, argument);
}
///
/// Creates a new
/// The Entity set in which the referenced element resides.
/// An A new DbRefExpression that references the element with the specified key values in the given Entity set.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbRefExpression CreateRefExpression(EntitySet entitySet, DbExpression refKeys)
{
EntityUtil.CheckArgumentNull(entitySet, "entitySet");
return new DbRefExpression(this, entitySet, refKeys, entitySet.ElementType);
}
///
/// Creates a new
/// The Entity set in which the referenced element resides.
/// An A new DbRefExpression that references the element with the specified key values in the given Entity set.
///
///
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbRefExpression CreateRefExpression(EntitySet entitySet, DbExpression refKeys, EntityType entityType)
{
return new DbRefExpression(this, entitySet, refKeys, entityType);
}
///
/// Creates a new
/// An A new DbDerefExpression that retrieves the specified Entity
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbDerefExpression CreateDerefExpression(DbExpression reference)
{
return new DbDerefExpression(this, reference);
}
///
/// Creates a new
/// The expression that provides the reference. This expression must have a reference Type with an Entity element type.
/// A new DbRefKeyExpression that retrieves the key values of the specified reference.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbRefKeyExpression CreateRefKeyExpression(DbExpression reference)
{
return new DbRefKeyExpression(this, reference);
}
///
/// Creates a new
/// The expression that provides the entity. This expression must have an entity result type.
/// A new DbEntityRefExpression that retrieves a reference to the specified entity.
///
///
/*CQT_PUBLIC_API(*/internal/*)*/ DbEntityRefExpression CreateEntityRefExpression(DbExpression entity)
{
return new DbEntityRefExpression(this, entity);
}
///
/// Creates a new
/// An expression that specifies the instance.
/// Type metadata for the treat-as type.
/// A new DbTreatExpression with the specified argument and type.
///
///
///
/// DbTreatExpression requires that
/*CQT_PUBLIC_API(*/internal/*)*/ DbTreatExpression CreateTreatExpression(DbExpression argument, TypeUsage treatType)
{
return new DbTreatExpression(this, treatType, argument);
}
#endregion
//
// Additional expression builders
// ...
#endregion
#endregion
#region Internal Implementation
///
/// Gets the kind of this command tree.
///
internal abstract DbCommandTreeKind CommandTreeKind { get; }
///
/// Gets the metadata workspace used by this command tree.
///
internal MetadataWorkspace MetadataWorkspace { get { return _metadata; } }
///
/// Gets the data space in which metadata used by this command tree must reside.
///
internal DataSpace DataSpace { get { return _dataSpace; } }
internal CommandTreeTypeHelper TypeHelper { get { return _typeHelp; } }
internal virtual void Validate(System.Data.Common.CommandTrees.Internal.Validator v) { }
internal bool ValidationRequired
{
get
{
bool valReq = _validatedVersion < _currentVersion;
EntityBid.Trace(" %d#, %d{bool}\n", this.ObjectId, valReq);
return valReq;
}
}
internal void SetValid()
{
EntityBid.Trace(" %d#\n", this.ObjectId);
_validatedVersion = _currentVersion;
}
internal void SetModified()
{
int prev = _currentVersion;
if (int.MaxValue == _currentVersion)
{
_currentVersion = 1;
_validatedVersion = 0;
}
else
{
_currentVersion++;
}
EntityBid.Trace(" %d# previous version=%d, new version=%d\n", this.ObjectId, prev, _currentVersion);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] // we intend for this to be public someday; called from test code for now.
internal void ClearParameters()
{
EntityBid.Trace(" %d#\n", this.ObjectId);
_paramMappings.Clear();
}
internal void CopyParametersTo(DbCommandTree tree)
{
foreach (KeyValuePair paramInfo in _paramMappings.Values)
{
tree.AddParameter(paramInfo.Key, paramInfo.Value);
}
}
internal bool HasParameter(string parameterName, TypeUsage parameterType)
{
Debug.Assert(!string.IsNullOrEmpty(parameterName), "Parameter name should not be null or empty");
Debug.Assert(parameterType != null, "Parameter type should not be null");
KeyValuePair foundParam;
if(this._paramMappings.TryGetValue(parameterName, out foundParam))
{
return (foundParam.Key.Equals(parameterName, StringComparison.Ordinal) &&
// SQLBUDT#545720: Equivalence is not a sufficient check (consider row types for TVPs) - equality is required.
TypeSemantics.IsStructurallyEqualTo(foundParam.Value, parameterType));
}
return false;
}
#region Dump/Print Support
internal void Dump(ExpressionDumper dumper)
{
//
// Dump information about this command tree to the specified ExpressionDumper
//
// First dump standard information - the DataSpace of the command tree and its parameters
//
Dictionary attrs = new Dictionary();
attrs.Add("DataSpace", this.DataSpace);
dumper.Begin(this.GetType().Name, attrs);
//
// The name and type of each Parameter in turn is added to the output
//
dumper.Begin("Parameters", null);
foreach (KeyValuePair param in this.Parameters)
{
Dictionary paramAttrs = new Dictionary();
paramAttrs.Add("Name", param.Key);
dumper.Begin("Parameter", paramAttrs);
dumper.Dump(param.Value, "ParameterType");
dumper.End("Parameter");
}
dumper.End("Parameters");
//
// Delegate to the derived type's implementation that dumps the structure of the command tree
//
this.DumpStructure(dumper);
//
// Matching call to End to correspond with the call to Begin above
//
dumper.End(this.GetType().Name);
}
internal abstract void DumpStructure(ExpressionDumper dumper);
internal string DumpXml()
{
//
// This is a convenience method that dumps the command tree in an XML format.
// This is intended primarily as a debugging aid to allow inspection of the tree structure.
//
// Create a new MemoryStream that the XML dumper should write to.
//
MemoryStream stream = new MemoryStream();
//
// Create the dumper
//
XmlExpressionDumper dumper = new XmlExpressionDumper(stream);
//
// Dump this tree and then close the XML dumper so that the end document tag is written
// and the output is flushed to the stream.
//
this.Dump(dumper);
dumper.Close();
//
// Construct a string from the resulting memory stream and return it to the caller
//
return XmlExpressionDumper.DefaultEncoding.GetString(stream.ToArray());
}
internal string Print()
{
return this.PrintTree(new ExpressionPrinter());
}
internal abstract string PrintTree(ExpressionPrinter printer);
#endregion
#region DbExpression Replacement
internal void Replace(ReplacerCallback callback)
{
using (new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
ExpressionReplacer replacer = new ExpressionReplacer(callback);
this.Replace(replacer);
}
}
internal abstract void Replace(ExpressionReplacer replacer);
#endregion
#region Tracing
internal void Trace()
{
if (EntityBid.AdvancedOn)
{
EntityBid.PutStrChunked(this.DumpXml());
EntityBid.Trace("\n");
}
else if (EntityBid.TraceOn)
{
EntityBid.PutStrChunked(this.Print());
EntityBid.Trace("\n");
}
}
#endregion
#region Container Tracking
internal void TrackContainer(EntityContainer container)
{
using (new EntityBid.ScopeAuto(" %d#", this.ObjectId))
{
if (!_containers.Contains(container))
{
EntityBid.Trace(" %d#, Adding container to tracked containers list: '%ls'\n", this.ObjectId, container.Name);
_containers.Add(container);
}
}
}
#endregion
#region Internal Helper API
internal DbApplyExpression CreateApplyExpressionByKind(DbExpressionKind applyKind, DbExpressionBinding input, DbExpressionBinding apply)
{
Debug.Assert(DbExpressionKind.CrossApply == applyKind || DbExpressionKind.OuterApply == applyKind, "Invalid ApplyType");
switch(applyKind)
{
case DbExpressionKind.CrossApply:
return this.CreateCrossApplyExpression(input, apply);
case DbExpressionKind.OuterApply:
return this.CreateOuterApplyExpression(input, apply);
default:
throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)applyKind);
}
}
internal DbExpression CreateJoinExpressionByKind(DbExpressionKind joinKind, DbExpression joinCondition, DbExpressionBinding input1, DbExpressionBinding input2)
{
Debug.Assert(DbExpressionKind.CrossJoin == joinKind ||
DbExpressionKind.FullOuterJoin == joinKind ||
DbExpressionKind.InnerJoin == joinKind ||
DbExpressionKind.LeftOuterJoin == joinKind,
"Invalid DbExpressionKind for CreateJoinExpressionByKind");
if (DbExpressionKind.CrossJoin == joinKind)
{
Debug.Assert(null == joinCondition, "Condition should not be specified for CrossJoin");
return this.CreateCrossJoinExpression(new DbExpressionBinding[2] { input1, input2 });
}
else
{
Debug.Assert(joinCondition != null, "Condition must be specified for non-CrossJoin");
switch (joinKind)
{
case DbExpressionKind.InnerJoin:
return this.CreateInnerJoinExpression(input1, input2, joinCondition);
case DbExpressionKind.LeftOuterJoin:
return this.CreateLeftOuterJoinExpression(input1, input2, joinCondition);
case DbExpressionKind.FullOuterJoin:
return this.CreateFullOuterJoinExpression(input1, input2, joinCondition);
default:
throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)joinKind);
}
}
}
internal static bool IsValidParameterName(string name)
{
return (!StringUtil.IsNullOrEmptyOrWhiteSpace(name) &&
_paramNameRegex.IsMatch(name));
}
private static readonly Regex _paramNameRegex = new Regex("^([A-Za-z])([A-Za-z0-9_])*$");
#endregion
#endregion
}
///
/// Describes the different "kinds" (classes) of command trees.
///
internal enum DbCommandTreeKind
{
Query,
Update,
Insert,
Delete,
Function,
}
}
// 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
- DataSpaceManager.cs
- RemoteHelper.cs
- ControlAdapter.cs
- ReflectionTypeLoadException.cs
- NullExtension.cs
- QueryStringParameter.cs
- LazyTextWriterCreator.cs
- ConnectionModeReader.cs
- AssemblyBuilderData.cs
- HeaderPanel.cs
- Style.cs
- ExceptionUtil.cs
- While.cs
- DataRowChangeEvent.cs
- DataGridViewRowContextMenuStripNeededEventArgs.cs
- DBSchemaRow.cs
- FormViewModeEventArgs.cs
- PartialCachingControl.cs
- Registry.cs
- LineServicesCallbacks.cs
- FontNamesConverter.cs
- MergablePropertyAttribute.cs
- TimeSpanSecondsConverter.cs
- XmlSchemaException.cs
- MenuAdapter.cs
- JulianCalendar.cs
- DataRelationPropertyDescriptor.cs
- RegistrySecurity.cs
- MenuItemCollection.cs
- SystemUdpStatistics.cs
- ProxyAttribute.cs
- TreeNodeSelectionProcessor.cs
- MediaTimeline.cs
- sqlpipe.cs
- Reference.cs
- OperationGenerator.cs
- SpanIndex.cs
- ResourcesGenerator.cs
- ListMarkerSourceInfo.cs
- BuildProvider.cs
- ScriptMethodAttribute.cs
- MinMaxParagraphWidth.cs
- XmlSchemaAny.cs
- RunInstallerAttribute.cs
- CallbackHandler.cs
- PkcsMisc.cs
- ValidatedControlConverter.cs
- XslNumber.cs
- SortDescription.cs
- HeaderedContentControl.cs
- EncoderExceptionFallback.cs
- DataTrigger.cs
- Timeline.cs
- Win32Native.cs
- LexicalChunk.cs
- ObfuscationAttribute.cs
- CompleteWizardStep.cs
- SqlCrossApplyToCrossJoin.cs
- CompModSwitches.cs
- PrintSchema.cs
- DefaultValueConverter.cs
- GPPOINT.cs
- ComPlusTypeValidator.cs
- StorageEntityTypeMapping.cs
- CachedFontFamily.cs
- Socket.cs
- TextShapeableCharacters.cs
- ScriptingSectionGroup.cs
- SQLDateTimeStorage.cs
- RequestQueryProcessor.cs
- EventRoute.cs
- Int32KeyFrameCollection.cs
- ExecutedRoutedEventArgs.cs
- CaseInsensitiveComparer.cs
- SocketPermission.cs
- Knowncolors.cs
- OpacityConverter.cs
- FragmentQuery.cs
- XmlLangPropertyAttribute.cs
- TrackingProfile.cs
- JournalEntryStack.cs
- RequestQueryParser.cs
- XmlLanguage.cs
- ParseHttpDate.cs
- PropertyInfoSet.cs
- GregorianCalendarHelper.cs
- PropertyGridCommands.cs
- EncryptedXml.cs
- MissingMethodException.cs
- NativeWindow.cs
- UnicodeEncoding.cs
- WebBrowsableAttribute.cs
- VoiceSynthesis.cs
- SessionStateSection.cs
- TextFormatterContext.cs
- Models.cs
- ZipIOExtraFieldElement.cs
- OrderedEnumerableRowCollection.cs
- WmpBitmapEncoder.cs
- propertytag.cs