public override LiteralExpression VisitLiteralValue(LiteralExpression expression) { if (expression.GetValue() == null) _writer.WriteNull(); else { switch (expression.PrimitiveType) { case PrimitiveType.None: if (expression.ExpressionType != typeof(DateTime)) goto case PrimitiveType.Object; _writer.WriteLiteral(expression.AsDateTime); break; case PrimitiveType.Object: _writer.WriteLiteral(expression.GetValue()); break; case PrimitiveType.Boolean: _writer.WriteLiteral(expression.AsBoolean); break; case PrimitiveType.Byte: case PrimitiveType.SByte: case PrimitiveType.Int16: case PrimitiveType.UInt16: case PrimitiveType.UInt32: case PrimitiveType.UInt64: _writer.WriteLiteral(expression.AsInt64, expression.ExpressionType); break; case PrimitiveType.Int32: case PrimitiveType.Int64: _writer.WriteLiteral(expression.AsInt64); break; case PrimitiveType.Char: _writer.WriteLiteral(expression.AsString[0]); break; case PrimitiveType.String: _writer.WriteLiteral(expression.AsString); break; case PrimitiveType.Single: case PrimitiveType.Decimal: _writer.WriteLiteral(expression.AsDouble, expression.ExpressionType); break; case PrimitiveType.Double: _writer.WriteLiteral(expression.AsDouble); break; default: throw ExceptionBuilder.UnhandledCaseLabel(expression.PrimitiveType); } } return expression; }
private static bool VisitLiteralValue(LiteralExpression node1, LiteralExpression node2) { return node2 != null && Equals(node1.GetValue(), node2.GetValue()); }
public virtual LiteralExpression VisitLiteralValue(LiteralExpression expression) { return expression; }
public override LiteralExpression VisitLiteralValue(LiteralExpression expression) { _ilEmitContext.AddParameter(expression, expression.GetValue(), expression.ExpressionType); return expression; }
public override LiteralExpression VisitLiteralValue(LiteralExpression expression) { ILParameterDeclaration ilParameterDeclaration = _ilEmitContext.GetParameters(expression)[0]; EmitLoadParameter(ilParameterDeclaration); return expression; }
public override LiteralExpression VisitLiteralValue(LiteralExpression expression) { _xmlWriter.WriteStartElement("literalExpression"); _xmlWriter.WriteStartElement("value"); WriteTypeAttribute(expression.ExpressionType); object value = expression.GetValue(); if (NullHelper.IsNull(value)) _xmlWriter.WriteAttributeString("value", "<null>"); else _xmlWriter.WriteAttributeString("value", value.ToString()); _xmlWriter.WriteEndElement(); _xmlWriter.WriteEndElement(); return expression; }
public override ExpressionNode VisitCaseExpression(CaseExpression expression) { // Ensure all nested expressions are fully resolved. base.VisitCaseExpression(expression); for (int i = 0; i < expression.WhenExpressions.Length; i++) { if (expression.WhenExpressions[i].ExpressionType == null || expression.ThenExpressions[i].ExpressionType == null) { return(expression); } } if (expression.ElseExpression != null && expression.ElseExpression.ExpressionType == null) { return(expression); } // Ok, all nested expressions could be fully resolved. Lets validate the CASE expression. // The semantic of CASE says that if no expression incl. ELSE does match the result is NULL. // So having an ELSE expression that returns NULL is quite redundant. LiteralExpression elseAsLiteral = expression.ElseExpression as LiteralExpression; if (elseAsLiteral != null && elseAsLiteral.IsNullValue) { expression.ElseExpression = null; } // All WHEN expressions must evaluate to bool. foreach (ExpressionNode whenExpression in expression.WhenExpressions) { if (whenExpression.ExpressionType != typeof(bool) && whenExpression.ExpressionType != typeof(DBNull)) { _errorReporter.WhenMustEvaluateToBoolIfCaseInputIsOmitted(whenExpression); } } // Check that all result expression incl. else share a common type. // // To do this and to support good error reporting we first try to find // the best common type. Any needed conversions or type errors are // ignored. Type commonResultType = expression.ThenExpressions[0].ExpressionType; for (int i = 1; i < expression.ThenExpressions.Length; i++) { commonResultType = _binder.ChooseBetterTypeConversion(commonResultType, expression.ThenExpressions[i].ExpressionType); } if (expression.ElseExpression != null) { commonResultType = _binder.ChooseBetterTypeConversion(expression.ElseExpression.ExpressionType, commonResultType); } // Now we know that commonResultType is the best type for all result expressions. // Insert cast nodes for all expressions that have a different type but are // implicit convertible and report errors for all expressions that not convertible. if (expression.ElseExpression != null) { expression.ElseExpression = _binder.ConvertExpressionIfRequired(expression.ElseExpression, commonResultType); } for (int i = 0; i < expression.ThenExpressions.Length; i++) { expression.ThenExpressions[i] = _binder.ConvertExpressionIfRequired(expression.ThenExpressions[i], commonResultType); } expression.ResultType = commonResultType; return(expression); }