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 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 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 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; }