/// <summary>
/// Convert expression to code.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="converter">Expression converter.</param>
/// <returns>Parts.</returns>
public override ICode Convert(MethodCallExpression expression, ExpressionConverter converter)
{
var newArray = expression.Arguments[ParamsIndex] as NewArrayExpression;
ICode[] args;
if (newArray != null)
{
args = new ICode[newArray.Expressions.Count];
for (int i = 0; i < newArray.Expressions.Count; i++)
{
var rowExp = newArray.Expressions[i];
ICode[] hcore;
var rowNewArray = rowExp as NewArrayExpression;
if (rowNewArray != null)
{
hcore = new ICode[rowNewArray.Expressions.Count];
for (int j = 0; j < rowNewArray.Expressions.Count; j++)
{
hcore[j] = converter.ConvertToCode(rowNewArray.Expressions[j]);
}
}
else
{
var row = converter.ConvertToObject(rowExp) as object[];
hcore = new ICode[row.Length];
for (int j = 0; j < row.Length; j++)
{
hcore[j] = converter.ConvertToCode(row[j]);
}
}
args[i] = Blanket(hcore);
}
}
else
{
var datas = converter.ConvertToObject(expression.Arguments[ParamsIndex]) as object[][];
args = new ICode[datas.Length];
for (int i = 0; i < args.Length; i++)
{
var row = datas[i];
var count = row.Length;
var hcore = new ICode[count];
for (int j = 0; j < count; j++)
{
hcore[j] = converter.ConvertToCode(row[j]);
}
args[i] = Blanket(hcore);
}
}
return(new HCode("VALUES".ToCode(), new VCode(args)
{
Separator = ", "
})
{
AddIndentNewLine = true, Indent = 1
});
}
/// <summary>
/// Convert expression to code.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="converter">Expression converter.</param>
/// <returns>Parts.</returns>
public override ICode Convert(MethodCallExpression expression, ExpressionConverter converter)
{
var text = (string)converter.ConvertToObject(expression.Arguments[0]);
var array = expression.Arguments[1] as NewArrayExpression;
return(new StringFormatCode(text, array.Expressions.Select(e => converter.ConvertToCode(e)).ToArray()));
}
/// <summary>
/// Convert expression to code.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="converter">Expression converter.</param>
/// <returns>Parts.</returns>
public override ICode Convert(MethodCallExpression expression, ExpressionConverter converter)
{
var obj = converter.ConvertToObject(expression.Arguments[0]);
var text = TowWaySqlSpec.ToStringFormat((string)obj);
var array = expression.Arguments[1] as NewArrayExpression;
return new StringFormatCode(text, array.Expressions.Select(e => converter.ConvertToCode(e)).ToArray());
}
ICode[] ConvertExpandArrayArgument(ExpressionConverter converter, ArgumentInfo argumentInfo, Expression argExp)
{
ICode[] code;
var newArrayExp = argExp as NewArrayExpression;
if (newArrayExp != null)
{
code = new ICode[newArrayExp.Expressions.Count];
for (int i = 0; i < newArrayExp.Expressions.Count; i++)
{
code[i] = converter.ConvertToCode(newArrayExp.Expressions[i]);
}
}
else
{
var obj = converter.ConvertToObject(argExp);
var list = new List <ICode>();
foreach (var e in (IEnumerable)obj)
{
list.Add(converter.ConvertToCode(e));
}
code = list.ToArray();
}
if (!string.IsNullOrEmpty(argumentInfo.ArrayExpandSeparator))
{
var isEmpty = true;
for (int i = code.Length - 1; 0 <= i; i--)
{
var currentIsEmpty = code[i].IsEmpty;
if (!isEmpty && !currentIsEmpty)
{
code[i] = new HCode(code[i], argumentInfo.ArrayExpandSeparator.ToCode())
{
EnableChangeLine = false
};
}
if (isEmpty)
{
isEmpty = currentIsEmpty;
}
}
}
if (0 < code.Length && argumentInfo.Separator != null)
{
code[code.Length - 1] = new HCode(code[code.Length - 1], argumentInfo.Separator)
{
EnableChangeLine = false
};
}
return(code);
}
/// <summary>
/// Create sql from expression contain formattable string.
/// </summary>
/// <typeparam name="T">Type of Selected object.</typeparam>
/// <param name="exp">expression.</param>
/// <returns>Sql object.</returns>
public static Sql FromExpressionContainFormattableString <T>(Expression exp) where T : class
{
var methodExp = exp as MethodCallExpression;
var db = DBDefineAnalyzer.GetDbInfo <T>();
var converter = new ExpressionConverter(db);
var obj = converter.ConvertToObject(methodExp.Arguments[0]);
var text = (string)obj;
var array = methodExp.Arguments[1] as NewArrayExpression;
var args = new ICode[array.Expressions.Count];
for (int i = 0; i < args.Length; i++)
{
args[i] = converter.ConvertToCode(array.Expressions[i]);
}
return(new Sql(new CodeParts.StringFormatCode(text, args)));
}
internal IEnumerable<ICode> InitAndConvertArguments(MethodCallExpression expression, ExpressionConverter converter)
{
lock (this)
{
if (string.IsNullOrEmpty(Name)) Name = expression.Method.Name.ToUpper();
if (NameCode == null) NameCode = Name.ToCode();
if (_startIndex == -1) _startIndex = expression.SkipMethodChain(0);
if (_isParamArray == null)
{
var paramsInfo = expression.Method.GetParameters();
_isParamArray = new bool[paramsInfo.Length];
for (int i = 0; i < paramsInfo.Length; i++)
{
_isParamArray[i] = paramsInfo[i].GetAttribute<ParamArrayAttribute>() != null;
}
}
}
var args = new List<ICode>();
for (int i = _startIndex; i < expression.Arguments.Count; i++)
{
var argExp = expression.Arguments[i];
if (_isParamArray[i])
{
var newArrayExp = argExp as NewArrayExpression;
if (newArrayExp != null)
{
foreach (var e in newArrayExp.Expressions) args.Add(converter.ConvertToCode(e));
}
else
{
var obj = converter.ConvertToObject(argExp);
foreach (var e in (IEnumerable)obj) args.Add(converter.ConvertToCode(e));
}
}
else
{
args.Add(converter.ConvertToCode(argExp));
}
}
return args;
}
/// <summary>
/// Convert expression to code.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="converter">Expression converter.</param>
/// <returns>Parts.</returns>
public override ICode Convert(NewExpression expression, ExpressionConverter converter)
{
var obj = converter.ConvertToObject(expression.Arguments[0]);
return (bool)obj ? converter.ConvertToCode(expression.Arguments[1]) : string.Empty.ToCode();
}
/// <summary>
/// Convert expression to code.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="converter">Expression converter.</param>
/// <returns>Parts.</returns>
public override ICode Convert(MethodCallExpression expression, ExpressionConverter converter)
{
var isOn = (bool)converter.ConvertToObject(expression.Arguments[expression.Arguments.Count - 1]);
return(new SingleTextCode(Name + " " + (isOn ? "ON" : "OFF")));
}
internal IEnumerable <ICode> InitAndConvertArguments(MethodCallExpression expression, ExpressionConverter converter)
{
lock (this)
{
if (string.IsNullOrEmpty(Name))
{
Name = expression.Method.Name.ToUpper();
}
if (NameCode == null)
{
NameCode = Name.ToCode();
}
if (_startIndex == -1)
{
_startIndex = expression.SkipMethodChain(0);
}
if (_isParamArray == null)
{
var paramsInfo = expression.Method.GetParameters();
_isParamArray = new bool[paramsInfo.Length];
for (int i = 0; i < paramsInfo.Length; i++)
{
_isParamArray[i] = paramsInfo[i].GetAttribute <ParamArrayAttribute>() != null;
}
}
}
var args = new List <ICode>();
for (int i = _startIndex; i < expression.Arguments.Count; i++)
{
var argExp = expression.Arguments[i];
if (_isParamArray[i])
{
var newArrayExp = argExp as NewArrayExpression;
if (newArrayExp != null)
{
bool isEmpty = true;
foreach (var e in newArrayExp.Expressions)
{
var argCode = converter.ConvertToCode(e);
if (isEmpty)
{
isEmpty = argCode.IsEmpty;
}
args.Add(argCode);
}
if (VanishIfEmptyParams && isEmpty)
{
return(null);
}
}
else
{
var obj = converter.ConvertToObject(argExp);
foreach (var e in (IEnumerable)obj)
{
args.Add(converter.ConvertToCode(e));
}
}
}
else
{
args.Add(converter.ConvertToCode(argExp));
}
}
return(args);
}
/// <summary>
/// Convert expression to code.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="converter">Expression converter.</param>
/// <returns>Parts.</returns>
public override ICode Convert(NewExpression expression, ExpressionConverter converter)
{
var obj = converter.ConvertToObject(expression.Arguments[0]);
return((bool)obj ? (ICode) new AroundCode(converter.ConvertToCode(expression.Arguments[1]), "(", ")") : string.Empty.ToCode());
}
