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);
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));
}
}
}
/// <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 + "'");
}
}
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));
}
}
}
