public override TreeNode Visit(DbConstantExpression e) { Check.NotNull(e, "e"); var retInfo = new TreeNode(); var stringVal = e.Value as string; if (stringVal != null) { stringVal = stringVal.Replace("\r\n", "\\r\\n"); var appendLength = stringVal.Length; if (_maxStringLength > 0) { appendLength = Math.Min(stringVal.Length, _maxStringLength); } retInfo.Text.Append("'"); retInfo.Text.Append(stringVal, 0, appendLength); if (stringVal.Length > appendLength) { retInfo.Text.Append("..."); } retInfo.Text.Append("'"); } else { retInfo.Text.Append(e.Value); } return(retInfo); }
public override TreeNode Visit(DbConstantExpression e) { Check.NotNull <DbConstantExpression>(e, nameof(e)); TreeNode treeNode = new TreeNode(); string str1 = e.Value as string; if (str1 != null) { string str2 = str1.Replace("\r\n", "\\r\\n"); int count = str2.Length; if (this._maxStringLength > 0) { count = Math.Min(str2.Length, this._maxStringLength); } treeNode.Text.Append("'"); treeNode.Text.Append(str2, 0, count); if (str2.Length > count) { treeNode.Text.Append("..."); } treeNode.Text.Append("'"); } else { treeNode.Text.Append(e.Value); } return(treeNode); }
private string GetValue(DbPropertyExpression prop, DbConstantExpression val) { var dbCastExpression = val.CastTo(prop.Property.TypeUsage); var value = dbCastExpression.ToString(); return(value); }
public override void Visit(DbConstantExpression expression) { Write(expression); _depth++; WriteLine(string.Format("Value: {0}", expression.Value)); _depth--; }
public override DbExpression Visit(DbConstantExpression exp) { if (exp.Value == null || exp.Value == DBNull.Value) { this._sqlBuilder.Append("NULL"); return(exp); } var objType = exp.Value.GetType(); if (objType == UtilConstants.TypeOfBoolean) { this._sqlBuilder.Append(((bool)exp.Value) ? "1" : "0"); return(exp); } else if (objType == UtilConstants.TypeOfString) { this._sqlBuilder.Append("N'", exp.Value, "'"); return(exp); } else if (objType.GetTypeInfo().IsEnum) { this._sqlBuilder.Append(((int)exp.Value).ToString()); return(exp); } this._sqlBuilder.Append(exp.Value); return(exp); }
public override SqlFragment Visit(DbConstantExpression expression) { PrimitiveTypeKind pt = ((PrimitiveType)expression.ResultType.EdmType).PrimitiveTypeKind; string literal = Metadata.GetNumericLiteral(pt, expression.Value); if (literal != null) { return(new LiteralFragment(literal)); } else if (pt == PrimitiveTypeKind.Boolean) { return(new LiteralFragment((bool)expression.Value ? "1" : "0")); } else { // use a parameter for non-numeric types so we get proper // quoting MySqlParameter p = new MySqlParameter(); p.ParameterName = CreateUniqueParameterName(); p.DbType = Metadata.GetDbType(expression.ResultType); p.Value = Metadata.NormalizeValue(expression.ResultType, expression.Value); Parameters.Add(p); return(new LiteralFragment(p.ParameterName)); } }
public override void Visit(DbConstantExpression expression) { Check.NotNull(expression, "expression"); var parameter = CreateParameter(expression.Value, expression.ResultType); _commandText.Append(parameter.ParameterName); }
public override void Visit(DbConstantExpression e) { Dictionary <string, object> attrs = new Dictionary <string, object>(); attrs.Add("Value", e.Value); Begin(e, attrs); End(e); }
private DbExpression RetrievalFunctionElementAtTranslate(TranslationContext context, MethodCallExpression exp, MethodInfo method) { var source = UnitTypeTranslate(context, exp.Arguments[0]); var contant = (ConstantExpression)exp.Arguments[1]; var value = new DbConstantExpression(contant.Type, contant.Value); return(new DbRetrievalFunctionExpression(source, method, value)); }
/// <summary> /// Evaluates a constant expression (trivial: the result is the constant expression) /// </summary> /// <param name="node">Constant expression node.</param> /// <returns>Constant expression</returns> public override PropagatorResult Visit(DbConstantExpression node) { Debug.Assert(null != node, "node is not visited when null"); // Flag the expression as 'preserve', since constants (by definition) cannot vary PropagatorResult result = PropagatorResult.CreateSimpleValue(PropagatorFlags.Preserve, node.Value); return(result); }
public override DbExpression Visit(DbConstantExpression expression) { var count = _originalParameterCount + ParameterValueMap.Count; var result = expression.ResultType.Parameter("p__linq__" + count); ParameterValueMap.Add(result.ParameterName, expression.Value); return(result); }
/// <summary> /// Evaluates a constant expression (trivial: the result is the constant expression) /// </summary> /// <param name="node"> Constant expression node. </param> /// <returns> Constant expression </returns> public override PropagatorResult Visit(DbConstantExpression node) { Check.NotNull(node, "node"); // Flag the expression as 'preserve', since constants (by definition) cannot vary var result = PropagatorResult.CreateSimpleValue(PropagatorFlags.Preserve, node.Value); return(result); }
public override Expression Visit(DbConstantExpression expression) { object value = expression.Value; Type type = edmTypeConverter.Convert(expression.ResultType); value = this.converter.ConvertClrObject(value, type); return Expression.Constant(value, type); }
public override Expression Visit(DbConstantExpression expression) { object value = expression.Value; Type type = edmTypeConverter.Convert(expression.ResultType); value = this.converter.ConvertClrObject(value, type); return(Expression.Constant(value, type)); }
//用于递归解析常量值。 private bool RecursiveConstantTranslate(TranslationContext context, Expression exp, out DbExpression value) { if (IsConstant(exp)) { var obj = Expression.Lambda(exp).Compile().DynamicInvoke(); value = new DbConstantExpression(exp.Type, obj); return(true); } value = null; return(false); }
/// <summary> /// Translates the <paramref name="constantExpression"/> into a string representation. /// </summary> /// <param name="constantExpression">The <see cref="DbConstantExpression"/> to translate.</param> /// <returns><see cref="string"/></returns> protected override DbExpression VisitConstantExpression(DbConstantExpression constantExpression) { if (constantExpression.Value == null) { return(ExpressionFactory.Sql("NULL")); } var parameterName = string.Format("@p{0}", Parameters.Count()); CreateParameter(parameterName, constantExpression.Value); return(ExpressionFactory.Sql(parameterName)); }
public override DbExpression Visit(DbConstantExpression expression) { if (this._currentProperty != null) { Tuple <FunctionParameter, bool> parameter = this.GetParameter(this._currentProperty, this._useOriginalValues); if (parameter != null) { return((DbExpression) new DbParameterReferenceExpression(parameter.Item1.TypeUsage, parameter.Item1.Name)); } } return(base.Visit(expression)); }
public override void Visit(DbConstantExpression e) { Check.NotNull <DbConstantExpression>(e, nameof(e)); this.Begin((DbExpression)e, new Dictionary <string, object>() { { "Value", e.Value } }); this.End((DbExpression)e); }
public override void Visit(DbConstantExpression expression) { if (_insertParametersValuesInSql) { _commandText.Append(VisitConstantExpression(expression)); } else { OleDbParameter parameter = CreateParameter(expression.Value, expression.ResultType); _commandText.Append(parameter.ParameterName); } }
public override void Visit(DbConstantExpression expression) { if (this._insertParametersValuesInSql) { this._commandText.Append(this.VisitConstantExpression(expression)); } else { var parameter = this.CreateParameter(expression.Value, expression.ResultType); this._commandText.Append(parameter.ParameterName); } }
private DbExpression RetrievalFunctionElementAtInlineTranslate(TranslationContext context, MethodCallExpression exp, MethodInfo method) { var source = ExpressionConvertUnitType(ExpressionTranslate(context, exp.Arguments[0])); if (source == null) { throw new TranslateException(exp.Arguments[0], Res.ExceptionIsNotUnitType); } var contant = (ConstantExpression)exp.Arguments[1]; var value = new DbConstantExpression(contant.Type, contant.Value); return(new DbRetrievalFunctionExpression(source, method, value)); }
public override void Visit(DbConstantExpression expression) { if (_createParameters) { IngresParameter parameter = CreateParameter(expression.Value, expression.ResultType); _commandText.Append(parameter.ParameterName); } else { _commandText.Append( _sqlGenerator.WriteSql(expression.Accept(_sqlGenerator))); } }
public override void Visit(DbConstantExpression expression) { Check.NotNull(expression, "expression"); if (_createParameters) { var parameter = CreateParameter(expression.Value, expression.ResultType); _commandText.Append(parameter.ParameterName); } else { _sqlGenerator.WriteSql(_commandText, expression.Accept(_sqlGenerator)); } }
public override void Visit(DbConstantExpression expression) { Check.NotNull <DbConstantExpression>(expression, nameof(expression)); SqlParameter parameter = this.CreateParameter(expression.Value, expression.ResultType, (string)null); if (this._createParameters) { this._commandText.Append(parameter.ParameterName); } else { using (SqlWriter writer = new SqlWriter(this._commandText.InnerBuilder)) this._sqlGenerator.WriteSql(writer, expression.Accept <ISqlFragment>((DbExpressionVisitor <ISqlFragment>) this._sqlGenerator)); } }
public override void Visit(DbConstantExpression expression) { if (generateParameters) { var parameter = CreateParameter(expression.Value, expression.ResultType); commandText.Append(parameter.ParameterName); } else { using (var writer = new SqlWriter(commandText)) { var sqlGenerator = new SqlGenerator(); sqlGenerator.WriteSql(writer, expression.Accept(sqlGenerator)); } } }
public override DbExpression Visit(DbConstantExpression expression) { DebugCheck.NotNull(expression); if (_currentProperty != null) { var parameter = GetParameter(_currentProperty); if (parameter != null) { return(new DbParameterReferenceExpression(parameter.Item1.TypeUsage, parameter.Item1.Name)); } } return(base.Visit(expression)); }
public override SqlFragment Visit(DbConstantExpression expression) { SqlFragment value = null; if (_onReturningSelect && values.TryGetValue(_columnsVisited.Peek(), out value)) { if (value is LiteralFragment) { MySqlParameter par = Parameters.Find(p => p.ParameterName == (value as LiteralFragment).Literal); if (par != null) { return(new LiteralFragment(par.ParameterName)); } } } return(base.Visit(expression)); }
public override void Visit(DbConstantExpression expression) { Check.NotNull(expression, "expression"); var parameter = CreateParameter(expression.Value, expression.ResultType); if (_createParameters) { _commandText.Append(parameter.ParameterName); } else { using (var writer = new SqlWriter(_commandText.InnerBuilder)) { _sqlGenerator.WriteSql(writer, expression.Accept(_sqlGenerator)); } } }
public override DbExpression Visit(DbConstantExpression exp) { if (exp.Value == null || exp.Value == DBNull.Value) { this.SqlBuilder.Append("NULL"); return(exp); } var objType = exp.Value.GetType(); if (objType == PublicConstants.TypeOfBoolean) { this.SqlBuilder.Append(((bool)exp.Value) ? "1" : "0"); return(exp); } else if (objType == PublicConstants.TypeOfString) { if (string.Empty.Equals(exp.Value)) { this.SqlBuilder.Append("'", exp.Value, "'"); } else { this.SqlBuilder.Append("N'", exp.Value, "'"); } return(exp); } else if (objType.IsEnum) { this.SqlBuilder.Append(Convert.ChangeType(exp.Value, Enum.GetUnderlyingType(objType)).ToString()); return(exp); } else if (NumericTypes.ContainsKey(exp.Value.GetType())) { this.SqlBuilder.Append(exp.Value); return(exp); } DbParameterExpression p = new DbParameterExpression(exp.Value); p.Accept(this); return(exp); }
public override void Visit(DbConstantExpression expression) { Check.NotNull(expression, "expression"); var parameter = CreateParameter(expression.Value, expression.ResultType); if (_createParameters) { if (_sqlGenerator.CharBoolModes[_sqlGenerator.CurrentColumn] && expression.ResultType.EdmType.Name == "Boolean") { Facet nullable; bool isNullable = expression.ResultType.Facets.TryGetValue("Nullable", false, out nullable) && (bool)nullable.Value; if (isNullable) { _commandText.Append("(CASE WHEN "); _commandText.Append(parameter.ParameterName); _commandText.Append(" IS NULL THEN NULL ELSE "); } _commandText.Append("(CASE WHEN "); _commandText.Append(parameter.ParameterName); _commandText.Append(" = 1 "); _commandText.Append(string.Format(CultureInfo.InvariantCulture, "THEN '{0}' ELSE '{1}' END) ", SqlProviderServices.CharBoolTrueChar, SqlProviderServices.CharBoolFalseChar)); if (isNullable) { _commandText.Append("END) "); } } else { _commandText.Append(parameter.ParameterName); } } else { using (var writer = new SqlWriter(_commandText.InnerBuilder)) { _sqlGenerator.WriteSql(writer, expression.Accept(_sqlGenerator)); } } }
public override DbExpression Visit(DbConstantExpression exp) { if (exp.Value == null || exp.Value == DBNull.Value) { this._sqlBuilder.Append("NULL"); return(exp); } var objType = exp.Value.GetType(); if (objType == UtilConstants.TypeOfBoolean) { this._sqlBuilder.Append(((bool)exp.Value) ? "1" : "0"); return(exp); } else if (objType == UtilConstants.TypeOfString) { this._sqlBuilder.Append("N'", exp.Value, "'"); return(exp); } else if (objType.IsEnum()) { this._sqlBuilder.Append(((int)exp.Value).ToString()); return(exp); } else if (NumericTypes.ContainsKey(exp.Value.GetType())) { this._sqlBuilder.Append(exp.Value); return(exp); } DbParameterExpression p = new DbParameterExpression(exp.Value); p.Accept(this); return(exp); }
private string GetValue(DbPropertyExpression prop, DbConstantExpression val) { var dbCastExpression = val.CastTo(prop.Property.TypeUsage); var value = dbCastExpression.ToString(); return value; }
public override void Visit(DbConstantExpression expression) { Check.NotNull(expression, "expression"); if (!_commandTree.Parameters.Any()) { var parameter = CreateParameter(expression.Value, expression.ResultType); _commandText.Append(parameter.ParameterName); } else { _commandText.Append(_sqlGenerator.WriteSql(expression.Accept(_sqlGenerator))); } }
public static bool ExpressionEquals(DbConstantExpression exp1, DbConstantExpression exp2) { return exp1.Value == exp2.Value; }
public override void Visit(DbConstantExpression e) { Debug.Assert(TypeSemantics.IsScalarType(e.ResultType), "Non-scalar type constant expressions are not supported."); var primitive = TypeHelpers.GetPrimitiveTypeUsageForScalar(e.ResultType); switch (((PrimitiveType)primitive.EdmType).PrimitiveTypeKind) { case PrimitiveTypeKind.Binary: var byteArray = e.Value as byte[]; if (byteArray != null) { _key.Append("'"); foreach (var b in byteArray) { _key.AppendFormat("{0:X2}", b); } _key.Append("'"); } else { throw new NotSupportedException(); } break; case PrimitiveTypeKind.String: var @string = e.Value as string; if (@string != null) { _key.Append("'"); _key.Append(@string.Replace("'", "''")); _key.Append("'"); } else { throw new NotSupportedException(); } break; case PrimitiveTypeKind.Boolean: case PrimitiveTypeKind.Byte: case PrimitiveTypeKind.DateTime: case PrimitiveTypeKind.Decimal: case PrimitiveTypeKind.Double: case PrimitiveTypeKind.Guid: case PrimitiveTypeKind.Single: case PrimitiveTypeKind.SByte: case PrimitiveTypeKind.Int16: case PrimitiveTypeKind.Int32: case PrimitiveTypeKind.Int64: case PrimitiveTypeKind.Time: case PrimitiveTypeKind.DateTimeOffset: _key.AppendFormat(CultureInfo.InvariantCulture, "{0}", e.Value); break; case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: var geometry = e.Value as DbGeometry; if (geometry != null) { _key.Append(geometry.AsText()); } else { throw new NotSupportedException(); } break; case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: var geography = e.Value as DbGeography; if (geography != null) { _key.Append(geography.AsText()); } else { throw new NotSupportedException(); } break; default: throw new NotSupportedException(); } _key.Append(":"); _key.Append(e.ResultType.Identity); }
/// <summary> /// Visitor pattern method for <see cref="DbConstantExpression" />. /// </summary> /// <param name="expression"> The DbConstantExpression that is being visited. </param> /// <exception cref="ArgumentNullException"> /// <paramref name="expression" /> /// is null /// </exception> public override void Visit(DbConstantExpression expression) { Check.NotNull(expression, "expression"); }
public override void Visit(DbConstantExpression expression) { }
public override SqlFragment Visit(DbConstantExpression expression) { SqlFragment value = null; if ( _onReturningSelect && values.TryGetValue(_columnsVisited.Peek(), out value)) { if (value is LiteralFragment) { MySqlParameter par = Parameters.Find(p => p.ParameterName == ( value as LiteralFragment ).Literal ); if (par != null) return new LiteralFragment(par.ParameterName); } } return base.Visit(expression); }
public override void Visit(DbConstantExpression e) { Dictionary<string, object> attrs = new Dictionary<string,object>(); attrs.Add("Value", e.Value); Begin(e, attrs); End(e); }
public override void Visit(DbConstantExpression expression) { Contract.Requires(expression != null); }
public override void Visit(DbConstantExpression expression) { var parameter = CreateParameter(expression.Value, expression.ResultType); _commandText.Append(parameter.ParameterName); }
// Generate an equality expression with one unknown operator and private DbExpression ImplementEqualityConstantAndUnknown( DbConstantExpression constant, DbExpression unknown, EqualsPattern pattern) { switch (pattern) { case EqualsPattern.Store: case EqualsPattern.PositiveNullEqualityNonComposable: // for Joins return constant.Equal(unknown); // either both are non-null, or one is null and the predicate result is undefined case EqualsPattern.PositiveNullEqualityComposable: if (!_funcletizer.RootContext.ContextOptions.UseCSharpNullComparisonBehavior) { return constant.Equal(unknown); // same as EqualsPattern.PositiveNullEqualityNonComposable } return constant.Equal(unknown).And(unknown.IsNull().Not()); // add more logic to avoid undefined result for true clr semantics default: Debug.Fail("unknown pattern"); return null; } }
/// <summary> /// Visitor pattern method for <see cref="DbConstantExpression" />. /// </summary> /// <param name="expression"> The DbConstantExpression that is being visited. </param> /// <exception cref="ArgumentNullException"> /// <paramref name="expression" /> /// is null /// </exception> public override void Visit(DbConstantExpression expression) { // #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here. Check.NotNull(expression, "expression"); }
/// <summary> /// Visitor pattern method for DbConstantExpression. /// </summary> /// <param name="expression"> The DbConstantExpression that is being visited. </param> public abstract void Visit(DbConstantExpression expression);
/// <summary> /// Function to translate the StartsWith, EndsWith and Contains canonical functions to LIKE expression in T-SQL /// and also add the trailing ESCAPE '~' when escaping of the search string for the LIKE expression has occurred /// </summary> /// <param name="sqlgen"></param> /// <param name="targetExpression"></param> /// <param name="constSearchParamExpression"></param> /// <param name="result"></param> /// <param name="insertPercentStart"></param> /// <param name="insertPercentEnd"></param> private static void TranslateConstantParameterForLike( SqlGenerator sqlgen, DbExpression targetExpression, DbConstantExpression constSearchParamExpression, SqlBuilder result, bool insertPercentStart, bool insertPercentEnd) { result.Append(targetExpression.Accept(sqlgen)); result.Append(" LIKE "); // If it's a DbConstantExpression then escape the search parameter if necessary. bool escapingOccurred; var searchParamBuilder = new StringBuilder(); if (insertPercentStart) { searchParamBuilder.Append("%"); } searchParamBuilder.Append( SqlProviderManifest.EscapeLikeText(constSearchParamExpression.Value as string, false, out escapingOccurred)); if (insertPercentEnd) { searchParamBuilder.Append("%"); } var escapedSearchParamExpression = constSearchParamExpression.ResultType.Constant(searchParamBuilder.ToString()); result.Append(escapedSearchParamExpression.Accept(sqlgen)); // If escaping did occur (special characters were found), then append the escape character used. if (escapingOccurred) { result.Append(" ESCAPE '" + SqlProviderManifest.LikeEscapeChar + "'"); } }