ICode Convert(UnaryExpression unary)
{
switch (unary.NodeType)
{
case ExpressionType.Not:
return(NotAddBrankets(Convert(unary.Operand)));
case ExpressionType.Convert:
var ret = Convert(unary.Operand);
var param = ret as ParameterCode;
if (param != null && param.Value != null && !SupportedTypeSpec.IsSupported(param.Value.GetType()))
{
var casted = ExpressionToObject.ConvertObject(unary.Type, param.Value);
return(new ParameterCode(param.Name, param.MetaId, new DbParamValueOnly()
{
Value = casted
}));
}
return(ret);
case ExpressionType.ArrayLength:
object obj;
ExpressionToObject.GetExpressionObject(unary.Operand, out obj);
return(new ParameterCode(((Array)obj).Length));
default:
return(Convert(unary.Operand));
}
}
/// <summary>
/// Convert expression to object.
/// </summary>
/// <param name="expression">expression.</param>
/// <returns>object.</returns>
public object ConvertToObject(Expression expression)
{
object obj;
if (!ExpressionToObject.GetExpressionObject(expression, out obj))
{
throw new NotSupportedException();
}
return(obj);
}
ICode Convert(BinaryExpression binary)
{
if (binary.NodeType == ExpressionType.ArrayIndex)
{
object ary;
ExpressionToObject.GetExpressionObject(binary.Left, out ary);
object index;
ExpressionToObject.GetExpressionObject(binary.Right, out index);
return(new ParameterCode(((Array)ary).GetValue((int)index)));
}
var left = Convert(binary.Left);
var right = Convert(binary.Right);
//sql + sql
//sql + clause
if (binary.NodeType == ExpressionType.Add)
{
if (typeof(SqlExpression).IsClassAndAssignableFromEx(binary.Type) ||
typeof(SqlExpression).IsClassAndAssignableFromEx(binary.Left.Type) ||
typeof(SqlExpression).IsClassAndAssignableFromEx(binary.Right.Type))
{
return(AddCode(left, right));
}
}
if (left.IsEmpty && right.IsEmpty)
{
return(string.Empty.ToCode());
}
if (left.IsEmpty)
{
return(right);
}
if (right.IsEmpty)
{
return(left);
}
//for null
var nullCheck = TryResolveNullCheck(left, binary.NodeType, right);
if (nullCheck != null)
{
return(nullCheck);
}
var isAddBlankets = CheckAddingBlanckets(binary, left, right);
return(new BinaryExpressionCode(new HCode(
isAddBlankets.Left ? AddBinaryExpressionBlankets(left) : left,
Convert(binary.Type, left, binary.NodeType, right),
isAddBlankets.Right ? AddBinaryExpressionBlankets(right) : right)));
}
ICode Convert(NewExpression newExp)
{
//symbol.
var symbol = newExp.GetNewConverter();
if (symbol != null)
{
return(symbol.Convert(newExp, this));
}
//object.
var value = ExpressionToObject.GetNewObject(newExp);
return(ConvertToCode(value));
}
ICode ResolveExpressionObject(Expression exp)
{
object obj;
if (!ExpressionToObject.GetExpressionObject(exp, out obj))
{
throw new NotSupportedException();
}
//object symbol.
//for example enum.
var symbol = exp.Type.GetObjectConverter();
if (symbol != null)
{
return(symbol.Convert(obj));
}
//IDbParam.
if (typeof(IDbParam).IsAssignableFromEx(exp.Type))
{
string name = string.Empty;
MetaId metaId = null;
var member = exp as MemberExpression;
if (member != null)
{
name = member.Member.Name;
metaId = new MetaId(member.Member);
}
var param = obj as IDbParam;
//use field name.
return(new ParameterCode(name, metaId, param));
}
//sql.
//example [ IN(exp) ]
var sqlExp = obj as Sql;
if (sqlExp != null)
{
Type type = null;
var types = sqlExp.GetType().GetGenericArgumentsEx();
if (0 < types.Length)
{
type = types[0];
}
return(SqlCode.Create(sqlExp.Code));
}
//others.
//Even if it is not a supported type, if it is correctly written it will be cast to the caller.
{
string name = string.Empty;
MetaId metaId = null;
var member = exp as MemberExpression;
if (member != null)
{
name = member.Member.Name;
metaId = new MetaId(member.Member);
}
//use field name.
return(new ParameterCode(name, metaId, new DbParamValueOnly()
{
Value = obj
}));
}
}
ICode Convert(MemberInitExpression memberInit)
{
var value = ExpressionToObject.GetMemberInitObject(memberInit);
return(ConvertToCode(value));
}
