public override AstElement Clone(Dictionary<AstElement, AstElement> alreadyClonedElements)
{
CastExpression result = new CastExpression();
result.Expression = (ExpressionNode)_expression.Clone(alreadyClonedElements);
result.TypeReference = (TypeReference)_typeReference.Clone(alreadyClonedElements);
result.ConvertMethod = _convertMethod;
return result;
}
private static bool VisitCastExpression(CastExpression node1, CastExpression node2)
{
return node2 != null &&
node1.TypeReference.TypeName == node2.TypeReference.TypeName &&
Visit(node1.Expression, node2.Expression);
}
public override ExpressionNode VisitCastExpression(CastExpression expression)
{
_writer.Write("CAST(");
Visit(expression.Expression);
_writer.Write(" AS ");
bool shortHandPrinted = false;
if (expression.TypeReference.ResolvedType != null)
{
PrimitiveType pt = Binder.GetPrimitiveType(expression.TypeReference.ResolvedType);
if (pt != PrimitiveType.None && pt != PrimitiveType.Null && pt != PrimitiveType.Object)
{
_writer.Write(pt.ToString().ToUpper(CultureInfo.InvariantCulture));
shortHandPrinted = true;
}
}
if (!shortHandPrinted)
{
if (expression.TypeReference.CaseSensitve)
_writer.Write("'");
_writer.Write(expression.TypeReference.TypeName);
if (expression.TypeReference.CaseSensitve)
_writer.Write("'");
}
_writer.Write(")");
return expression;
}
private ExpressionNode ParsePrimaryExpression()
{
switch (_token.Id)
{
case TokenId.NULL:
NextToken();
return LiteralExpression.FromNull();
case TokenId.TRUE:
case TokenId.FALSE:
return ParseBooleanLiteral();
case TokenId.Date:
return ParseDateLiteral();
case TokenId.Number:
return ParseNumberLiteral();
case TokenId.String:
return LiteralExpression.FromString(ParseString());
case TokenId.EXISTS:
{
ExistsSubselect result = new ExistsSubselect();
NextToken();
Match(TokenId.LeftParentheses);
result.Query = ParseQuery();
Match(TokenId.RightParentheses);
return result;
}
case TokenId.ParameterMarker:
{
_rangeRecorder.Begin();
NextToken();
Identifier name = ParseIdentifier();
SourceRange nameSourceRange = _rangeRecorder.End();
ParameterExpression result = new ParameterExpression();
result.Name = name;
result.NameSourceRange = nameSourceRange;
return result;
}
case TokenId.CAST:
{
NextToken();
CastExpression castExpression = new CastExpression();
Match(TokenId.LeftParentheses);
castExpression.Expression = ParseExpression();
Match(TokenId.AS);
castExpression.TypeReference = ParseTypeReference();
Match(TokenId.RightParentheses);
return castExpression;
}
case TokenId.CASE:
{
NextToken();
CaseExpression caseExpression = new CaseExpression();
if (_token.Id != TokenId.WHEN && _token.Id != TokenId.ELSE && _token.Id != TokenId.END)
caseExpression.InputExpression = ParseExpression();
List<ExpressionNode> whenExpressionList = new List<ExpressionNode>();
List<ExpressionNode> expressionList = new List<ExpressionNode>();
if (_token.Id != TokenId.WHEN)
{
Match(TokenId.WHEN);
}
else
{
while (_token.Id == TokenId.WHEN)
{
NextToken();
whenExpressionList.Add(ParseExpression());
Match(TokenId.THEN);
expressionList.Add(ParseExpression());
}
}
caseExpression.WhenExpressions = whenExpressionList.ToArray();
caseExpression.ThenExpressions = expressionList.ToArray();
if (_token.Id == TokenId.ELSE)
{
NextToken();
caseExpression.ElseExpression = ParseExpression();
}
Match(TokenId.END);
return caseExpression;
}
case TokenId.COALESCE:
{
NextToken();
CoalesceExpression coalesceExpression = new CoalesceExpression();
coalesceExpression.Expressions = ParseExpressionList();
return coalesceExpression;
}
case TokenId.NULLIF:
{
NextToken();
NullIfExpression nullIfExpression = new NullIfExpression();
Match(TokenId.LeftParentheses);
nullIfExpression.LeftExpression = ParseExpression();
Match(TokenId.Comma);
nullIfExpression.RightExpression = ParseExpression();
Match(TokenId.RightParentheses);
return nullIfExpression;
}
case TokenId.Identifier:
{
_rangeRecorder.Begin();
Identifier name = ParseIdentifier();
SourceRange nameSourceRange = _rangeRecorder.End();
if (_token.Id != TokenId.LeftParentheses)
{
NameExpression result = new NameExpression();
result.Name = name;
result.NameSourceRange = nameSourceRange;
return result;
}
else
{
bool hasAsteriskModifier;
ExpressionNode[] args;
if (_lookahead.Id != TokenId.Multiply)
{
hasAsteriskModifier = false;
args = ParseExpressionList();
}
else
{
NextToken();
NextToken();
Match(TokenId.RightParentheses);
hasAsteriskModifier = true;
args = new ExpressionNode[0];
}
FunctionInvocationExpression result = new FunctionInvocationExpression();
result.Name = name;
result.NameSourceRange = nameSourceRange;
result.Arguments = args;
result.HasAsteriskModifier = hasAsteriskModifier;
return result;
}
}
case TokenId.LeftParentheses:
{
NextToken();
ExpressionNode expr;
if (_token.Id != TokenId.SELECT)
{
expr = ParseExpression();
}
else
{
SingleRowSubselect singleRowSubselect = new SingleRowSubselect();
singleRowSubselect.Query = ParseQuery();
expr = singleRowSubselect;
}
Match(TokenId.RightParentheses);
return expr;
}
default:
{
_errorReporter.SimpleExpressionExpected(_token.Range, _token.Text);
return LiteralExpression.FromNull();
}
}
}
public virtual ExpressionNode VisitCastExpression(CastExpression expression)
{
expression.Expression = VisitExpression(expression.Expression);
return expression;
}
private ExpressionNode ConvertExpressionIfRequired(ExpressionNode expression, Type targetType, bool enableDownCast)
{
if (expression.ExpressionType == typeof(DBNull))
return LiteralExpression.FromTypedNull(targetType);
if (ConversionNeeded(expression.ExpressionType, targetType))
{
MethodInfo methodInfo = GetImplicitConversionMethod(expression.ExpressionType, targetType);
if (methodInfo == null)
methodInfo = GetExplicitConversionMethod(expression.ExpressionType, targetType);
if (methodInfo != null)
{
CastExpression result = new CastExpression(expression, targetType);
result.ConvertMethod = methodInfo;
return result;
}
if (enableDownCast && AllowsDownCast(expression.ExpressionType, targetType))
{
CastExpression result = new CastExpression(expression, targetType);
return result;
}
// Conversion not possible, report an error.
_errorReporter.CannotCast(expression, targetType);
}
return expression;
}
public override ExpressionNode VisitCastExpression(CastExpression expression)
{
expression.Expression = VisitExpression(expression.Expression);
if (expression.TypeReference.ResolvedType == null)
{
Type targetType = Binder.BindType(expression.TypeReference.TypeName, expression.TypeReference.CaseSensitve);
expression.TypeReference.ResolvedType = targetType;
if (targetType == null)
{
ErrorReporter.UndeclaredType(expression.TypeReference.TypeNameSourceRange, expression.TypeReference.TypeName);
}
else if (expression.Expression.ExpressionType != null)
{
return Binder.ConvertOrDowncastExpressionIfRequired(expression.Expression, targetType);
}
}
return expression;
}
public override ExpressionNode VisitCastExpression(CastExpression expression)
{
if (expression.ConvertMethod != null)
{
// This is a cast using a conversion method
EmitCall(expression.ConvertMethod, null, expression.Expression);
}
else
{
// It is a regular downcast.
// Nothing to do.
Visit(expression.Expression);
}
return expression;
}
public override ExpressionNode VisitCastExpression(CastExpression expression)
{
base.VisitCastExpression(expression);
if (!Binder.ConversionNeeded(expression.Expression.ExpressionType, expression.ExpressionType))
return expression.Expression;
ConstantExpression expressionAsConstant = expression.Expression as ConstantExpression;
if (expressionAsConstant != null)
{
if (expressionAsConstant.IsNullValue)
return LiteralExpression.FromTypedNull(expression.ExpressionType);
try
{
return LiteralExpression.FromTypedValue(expression.GetValue(), expression.ExpressionType);
}
catch (RuntimeException ex)
{
_errorReporter.CannotFoldConstants(ex);
}
}
return expression;
}
public override ExpressionNode VisitCastExpression(CastExpression expression)
{
_xmlWriter.WriteStartElement("castExpression");
_xmlWriter.WriteAttributeString("typeName", expression.TypeReference.TypeName);
WriteTypeAttribute(expression.ExpressionType);
WriteAstNode("expression", expression.Expression);
_xmlWriter.WriteEndElement();
return expression;
}
