public override DbExpression Visit(DbIsNullExpression expression)
{
DebugCheck.NotNull(expression);
var propertyExpression
= expression.Argument as DbPropertyExpression;
if (propertyExpression != null)
{
var parameter
= GetParameter((EdmProperty)propertyExpression.Property, originalValue: true);
if (parameter != null)
{
if (parameter.Item2)
{
// Current value, remove condition
return(null);
}
var parameterReferenceExpression
= new DbParameterReferenceExpression(parameter.Item1.TypeUsage, parameter.Item1.Name);
var equalityPredicate
= propertyExpression.Equal(parameterReferenceExpression);
var nullPredicate
= propertyExpression.IsNull().And(parameterReferenceExpression.IsNull());
return(equalityPredicate.Or(nullPredicate));
}
}
return(base.Visit(expression));
}
public override TreeNode Visit(DbParameterReferenceExpression e)
{
TreeNode retInfo = new TreeNode();
retInfo.Text.AppendFormat("@{0}", e.ParameterName);
return(retInfo);
}
public override DbExpression Visit(DbParameterReferenceExpression expression)
{
Check.NotNull(expression, "expression");
var result = base.Visit(expression);
if (result.ExpressionKind
== DbExpressionKind.ParameterReference)
{
var paramRef = result as DbParameterReferenceExpression;
DbParameterReferenceExpression foundParam;
if (paramMappings.TryGetValue(paramRef.ParameterName, out foundParam))
{
// SQLBUDT#545720: Equivalence is not a sufficient check (consider row types for TVPs) - equality is required.
if (!TypeSemantics.IsEqual(paramRef.ResultType, foundParam.ResultType))
{
ThrowInvalid(Strings.Cqt_Validator_InvalidIncompatibleParameterReferences(paramRef.ParameterName));
}
}
else
{
paramMappings.Add(paramRef.ParameterName, paramRef);
}
}
return(result);
}
public override void Visit(DbParameterReferenceExpression expression)
{
Write(expression);
_depth++;
Write("ParameterName", expression.ParameterName);
_depth--;
}
public override void Visit(DbParameterReferenceExpression e)
{
_key.Append("@");
_key.Append(e.ParameterName);
_key.Append(":");
_key.Append(e.ResultType.Identity);
}
public override void Visit(DbParameterReferenceExpression expression)
{
if (expression == null)
{
throw new ArgumentException("expression");
}
}
public override TreeNode Visit(DbParameterReferenceExpression e)
{
Check.NotNull <DbParameterReferenceExpression>(e, nameof(e));
TreeNode treeNode = new TreeNode();
treeNode.Text.AppendFormat("@{0}", (object)e.ParameterName);
return(treeNode);
}
public override void Visit(DbParameterReferenceExpression e)
{
Dictionary <string, object> attrs = new Dictionary <string, object>();
attrs.Add("ParameterName", e.ParameterName);
Begin(e, attrs);
End(e);
}
public override void Visit(DbParameterReferenceExpression e)
{
Check.NotNull <DbParameterReferenceExpression>(e, nameof(e));
this._key.Append("@");
this._key.Append(e.ParameterName);
this._key.Append(":");
this._key.Append(e.ResultType.Identity);
}
/// <summary>
/// Implements the visitor pattern for a reference to a parameter declared on the command tree
/// that contains this expression.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The implemented visitor.</returns>
public override DbExpression Visit(DbParameterReferenceExpression expression)
{
if (ParameterCollection.Contains(expression.ParameterName))
{
return(DbExpressionBuilder.Constant(ParameterCollection[expression.ParameterName].Value));
}
return(base.Visit(expression));
}
internal QueryParameterExpression(
DbParameterReferenceExpression parameterReference,
Expression funcletizedExpression,
IEnumerable <ParameterExpression> compiledQueryParameters)
{
this._compiledQueryParameters = compiledQueryParameters ?? Enumerable.Empty <ParameterExpression>();
this._parameterReference = parameterReference;
this._type = funcletizedExpression.Type;
this._funcletizedExpression = funcletizedExpression;
this._cachedDelegate = (Delegate)null;
}
public override void Visit(DbParameterReferenceExpression e)
{
Check.NotNull <DbParameterReferenceExpression>(e, nameof(e));
this.Begin((DbExpression)e, new Dictionary <string, object>()
{
{
"ParameterName",
(object)e.ParameterName
}
});
this.End((DbExpression)e);
}
public override void Visit(DbParameterReferenceExpression expression)
{
Check.NotNull(expression, "expression");
var parameter
= CreateParameter(
DBNull.Value,
expression.ResultType,
"@" + expression.ParameterName);
_commandText.Append(parameter.ParameterName);
}
internal QueryParameterExpression(
DbParameterReferenceExpression parameterReference,
Expression funcletizedExpression,
IEnumerable <ParameterExpression> compiledQueryParameters)
{
EntityUtil.CheckArgumentNull(parameterReference, "parameterReference");
EntityUtil.CheckArgumentNull(funcletizedExpression, "funcletizedExpression");
_compiledQueryParameters = compiledQueryParameters ?? Enumerable.Empty <ParameterExpression>();
_parameterReference = parameterReference;
_type = funcletizedExpression.Type;
_funcletizedExpression = funcletizedExpression;
_cachedDelegate = null;
}
internal QueryParameterExpression(
DbParameterReferenceExpression parameterReference,
Expression funcletizedExpression,
IEnumerable<ParameterExpression> compiledQueryParameters)
{
Contract.Requires(parameterReference != null);
Contract.Requires(funcletizedExpression != null);
_compiledQueryParameters = compiledQueryParameters ?? Enumerable.Empty<ParameterExpression>();
_parameterReference = parameterReference;
_type = funcletizedExpression.Type;
_funcletizedExpression = funcletizedExpression;
_cachedDelegate = null;
}
internal QueryParameterExpression(
DbParameterReferenceExpression parameterReference,
Expression funcletizedExpression,
IEnumerable <ParameterExpression> compiledQueryParameters)
{
DebugCheck.NotNull(parameterReference);
DebugCheck.NotNull(funcletizedExpression);
_compiledQueryParameters = compiledQueryParameters ?? Enumerable.Empty <ParameterExpression>();
_parameterReference = parameterReference;
_type = funcletizedExpression.Type;
_funcletizedExpression = funcletizedExpression;
_cachedDelegate = null;
}
internal QueryParameterExpression(
DbParameterReferenceExpression parameterReference,
Expression funcletizedExpression,
IEnumerable<ParameterExpression> compiledQueryParameters)
{
DebugCheck.NotNull(parameterReference);
DebugCheck.NotNull(funcletizedExpression);
_compiledQueryParameters = compiledQueryParameters ?? Enumerable.Empty<ParameterExpression>();
_parameterReference = parameterReference;
_type = funcletizedExpression.Type;
_funcletizedExpression = funcletizedExpression;
_cachedDelegate = null;
}
public override Expression Visit(DbParameterReferenceExpression expression)
{
Type type = edmTypeConverter.Convert(expression.ResultType);
ConstructorInfo parameterPlaceholderConstructor =
typeof(NMemory.StoredProcedures.Parameter<>)
.MakeGenericType(type)
.GetConstructors()
.Single(c => c.GetParameters().Count() == 1);
NewExpression parameter =
Expression.New(
parameterPlaceholderConstructor,
Expression.Constant(expression.ParameterName));
// Add implicit conversion
return Expression.Convert(parameter, type);
}
public override Expression Visit(DbParameterReferenceExpression expression)
{
Type type = edmTypeConverter.Convert(expression.ResultType);
ConstructorInfo parameterPlaceholderConstructor =
typeof(NMemory.StoredProcedures.Parameter <>)
.MakeGenericType(type)
.GetConstructors()
.Single(c => c.GetParameters().Count() == 1);
NewExpression parameter =
Expression.New(
parameterPlaceholderConstructor,
Expression.Constant(expression.ParameterName));
// Add implicit conversion
return(Expression.Convert(parameter, type));
}
public override DbExpression Visit(DbIsNullExpression expression)
{
DbPropertyExpression left = expression.Argument as DbPropertyExpression;
if (left != null)
{
Tuple <FunctionParameter, bool> parameter = this.GetParameter((EdmProperty)left.Property, true);
if (parameter != null)
{
if (parameter.Item2)
{
return((DbExpression)null);
}
DbParameterReferenceExpression referenceExpression = new DbParameterReferenceExpression(parameter.Item1.TypeUsage, parameter.Item1.Name);
return((DbExpression)left.Equal((DbExpression)referenceExpression).Or((DbExpression)left.IsNull().And((DbExpression)referenceExpression.IsNull())));
}
}
return(base.Visit(expression));
}
internal override Expression Visit(Expression exp)
{
if (exp != null)
{
if (!_funcletizer._linqExpressionStack.Add(exp))
{
// This expression is already in the stack.
throw EntityUtil.InvalidOperation(Strings.ELinq_CycleDetected);
}
try
{
if (_isClientConstant(exp))
{
return(InlineValue(exp, false));
}
else if (_isClientVariable(exp))
{
TypeUsage queryParameterType;
if (_funcletizer.TryGetTypeUsageForTerminal(exp.Type, out queryParameterType))
{
DbParameterReferenceExpression parameterReference = queryParameterType.Parameter(_funcletizer.GenerateParameterName());
return(new QueryParameterExpression(parameterReference, exp, _funcletizer._compiledQueryParameters));
}
else if (_funcletizer.IsCompiledQuery)
{
throw InvalidCompiledQueryParameterException(exp);
}
else
{
return(InlineValue(exp, true));
}
}
return(base.Visit(exp));
}
finally
{
_funcletizer._linqExpressionStack.Remove(exp);
}
}
return(base.Visit(exp));
}
internal System.Data.Entity.Core.Query.InternalTrees.Node GetInternalTree(
Command targetIqtCommand,
IList <System.Data.Entity.Core.Query.InternalTrees.Node> targetIqtArguments)
{
if (this.m_internalTreeNode == null)
{
DiscriminatorMap discriminatorMap;
Command command = ITreeGenerator.Generate(this.GenerateFunctionView(out discriminatorMap), discriminatorMap);
System.Data.Entity.Core.Query.InternalTrees.Node root = command.Root;
System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(root.Op.OpType == OpType.PhysicalProject, "Expected a physical projectOp at the root of the tree - found " + (object)root.Op.OpType);
PhysicalProjectOp op = (PhysicalProjectOp)root.Op;
System.Data.Entity.Core.Query.InternalTrees.Node child0 = root.Child0;
command.DisableVarVecEnumCaching();
System.Data.Entity.Core.Query.InternalTrees.Node relOpNode = child0;
Var computedVar = op.Outputs[0];
if (!Command.EqualTypes(op.ColumnMap.Type, this.FunctionImport.ReturnParameter.TypeUsage))
{
TypeUsage typeUsage = ((CollectionType)this.FunctionImport.ReturnParameter.TypeUsage.EdmType).TypeUsage;
System.Data.Entity.Core.Query.InternalTrees.Node node1 = command.CreateNode((Op)command.CreateVarRefOp(computedVar));
System.Data.Entity.Core.Query.InternalTrees.Node node2 = command.CreateNode((Op)command.CreateSoftCastOp(typeUsage), node1);
System.Data.Entity.Core.Query.InternalTrees.Node varDefListNode = command.CreateVarDefListNode(node2, out computedVar);
ProjectOp projectOp = command.CreateProjectOp(computedVar);
relOpNode = command.CreateNode((Op)projectOp, relOpNode, varDefListNode);
}
this.m_internalTreeNode = command.BuildCollect(relOpNode, computedVar);
}
Dictionary <string, System.Data.Entity.Core.Query.InternalTrees.Node> viewArguments = new Dictionary <string, System.Data.Entity.Core.Query.InternalTrees.Node>(this.m_commandParameters.Length);
for (int index = 0; index < this.m_commandParameters.Length; ++index)
{
DbParameterReferenceExpression commandParameter = this.m_commandParameters[index];
System.Data.Entity.Core.Query.InternalTrees.Node node = targetIqtArguments[index];
if (TypeSemantics.IsEnumerationType(node.Op.Type))
{
node = targetIqtCommand.CreateNode((Op)targetIqtCommand.CreateSoftCastOp(TypeHelpers.CreateEnumUnderlyingTypeUsage(node.Op.Type)), node);
}
viewArguments.Add(commandParameter.ParameterName, node);
}
return(FunctionImportMappingComposable.FunctionViewOpCopier.Copy(targetIqtCommand, this.m_internalTreeNode, viewArguments));
}
public override DbExpression Visit(DbParameterReferenceExpression expression)
{
Check.NotNull <DbParameterReferenceExpression>(expression, nameof(expression));
DbExpression dbExpression = base.Visit(expression);
if (dbExpression.ExpressionKind == DbExpressionKind.ParameterReference)
{
DbParameterReferenceExpression referenceExpression1 = dbExpression as DbParameterReferenceExpression;
DbParameterReferenceExpression referenceExpression2;
if (this.paramMappings.TryGetValue(referenceExpression1.ParameterName, out referenceExpression2))
{
if (!TypeSemantics.IsEqual(referenceExpression1.ResultType, referenceExpression2.ResultType))
{
this.ThrowInvalid(Strings.Cqt_Validator_InvalidIncompatibleParameterReferences((object)referenceExpression1.ParameterName));
}
}
else
{
this.paramMappings.Add(referenceExpression1.ParameterName, referenceExpression1);
}
}
return(dbExpression);
}
public override void Visit(DbParameterReferenceExpression expression)
{
throw new NotSupportedException("Visit(\"ParameterReferenceExpression\") is not supported.");
}
public override void Visit(DbParameterReferenceExpression expression) { }
public override void Visit(DbParameterReferenceExpression expression)
{
if (expression == null) throw new ArgumentException("expression");
}
public override bool Visit(DbParameterReferenceExpression expression)
{
return(false);
}
public override void Visit(DbParameterReferenceExpression e)
{
_key.Append("@");
_key.Append(e.ParameterName);
_key.Append(":");
_key.Append(e.ResultType.Identity);
}
public override void Visit(DbParameterReferenceExpression expression)
{
Check.NotNull(expression, "expression");
var parameter
= CreateParameter(
DBNull.Value,
expression.ResultType,
"@" + expression.ParameterName);
_commandText.Append(parameter.ParameterName);
}
public override void Visit(DbParameterReferenceExpression expression)
{
throw new NotSupportedException("Visit(\"DbParameterReferenceExpression\") is not supported.");
}
public override void Visit(DbParameterReferenceExpression expression)
{
Check.NotNull(expression, "expression");
paramMappings[expression.ParameterName] = expression;
}
public override void Visit(DbParameterReferenceExpression e)
{
Dictionary<string, object> attrs = new Dictionary<string, object>();
attrs.Add("ParameterName", e.ParameterName);
Begin(e, attrs);
End(e);
}
public override object Visit(DbParameterReferenceExpression expression)
{
return(null);
}
public override void Visit(DbParameterReferenceExpression expression)
{
Check.NotNull(expression, "expression");
paramMappings[expression.ParameterName] = expression;
}
public override DbExpression Visit(DbParameterReferenceExpression expression)
{
// Inline parameters
return DbExpressionBuilder.Constant(_parameters[expression.ParameterName].Value);
}
/// <summary> /// Visitor pattern method for DbParameterReferenceExpression. /// </summary> /// <param name="expression"> The DbParameterReferenceExpression that is being visited. </param> public abstract void Visit(DbParameterReferenceExpression expression);
public override DbExpression Visit(DbParameterReferenceExpression expression)
{
System.Diagnostics.Debug.Print("Visit(DbParameterReferenceExpression): {0}", expression);
return base.Visit(expression);
}
public override LegacyCommandTrees.DbExpression Visit(DbParameterReferenceExpression expression)
{
return(GetLegacyTypeUsage(expression.ResultType).Parameter(expression.ParameterName));
}
internal QueryParameterExpression(
DbParameterReferenceExpression parameterReference,
Expression funcletizedExpression,
IEnumerable<ParameterExpression> compiledQueryParameters)
{
EntityUtil.CheckArgumentNull(parameterReference, "parameterReference");
EntityUtil.CheckArgumentNull(funcletizedExpression, "funcletizedExpression");
_compiledQueryParameters = compiledQueryParameters ?? Enumerable.Empty<ParameterExpression>();
_parameterReference = parameterReference;
_type = funcletizedExpression.Type;
_funcletizedExpression = funcletizedExpression;
_cachedDelegate = null;
}
/// <summary>
/// Visitor pattern method for <see cref="DbParameterReferenceExpression" />.
/// </summary>
/// <param name="expression"> The DbParameterReferenceExpression that is being visited. </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="expression" />
/// is null
/// </exception>
public override void Visit(DbParameterReferenceExpression expression)
{
// #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
Check.NotNull(expression, "expression");
}
public override DbExpression Visit(DbParameterReferenceExpression expression)
{
// Inline parameters
return(DbExpressionBuilder.Constant(_parameters[expression.ParameterName].Value));
}
public override void Visit(DbParameterReferenceExpression expression)
{
DebugCheck.NotNull(expression);
_where.Append("@" + expression.ParameterName);
}
/// <summary>
/// Visitor pattern method for <see cref="DbParameterReferenceExpression" />.
/// </summary>
/// <param name="expression"> The DbParameterReferenceExpression that is being visited. </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="expression" />
/// is null
/// </exception>
public override void Visit(DbParameterReferenceExpression expression)
{
Check.NotNull(expression, "expression");
}
public override void Visit(DbParameterReferenceExpression expression)
{
DebugCheck.NotNull(expression);
_where.Append("@" + expression.ParameterName);
}
public override ISqlFragment Visit(DbParameterReferenceExpression e)
{
// Do not quote this name.
// We are not checking that e.Name has no illegal characters. e.g. space
return(new SqlBuilder("@", e.ParameterName));
}
public override SqlFragment Visit(DbParameterReferenceExpression expression)
{
return(new LiteralFragment("@" + expression.ParameterName));
}
public override void Visit(DbParameterReferenceExpression expression)
{
Debug.Assert(expression != null, "Command tree subexpressions should never be null");
paramMappings[expression.ParameterName] = expression;
}
public override void Visit(DbParameterReferenceExpression expression)
{
Contract.Requires(expression != null);
}
public override DbExpressionEntitySetInfo Visit(DbParameterReferenceExpression expression)
{
return(null);
}
public override DbExpression Visit(DbParameterReferenceExpression expression)
{
Check.NotNull(expression, "expression");
if (objectParameters.Contains(expression.ParameterName))
{
// A DbNullExpression is required for null values; DbConstantExpression otherwise.
var objParam = objectParameters[expression.ParameterName];
if (null == objParam.Value)
{
return expression.ResultType.Null();
}
else
{
// This will throw if the value is incompatible with the result type.
return expression.ResultType.Constant(objParam.Value);
}
}
return expression;
}
