private static string VisitMemberAccess <T>(MemberExpression m, DialectProvider dialect, string alias)
{
Type elementType;
if (m.Expression != null && m.Expression.Type == typeof(T))
{
var parentPropertyMap = Reflector.GetPropertyMap(typeof(T));
ReflectedProperty property;
parentPropertyMap.TryGetValue((PropertyInfo)m.Member, out property);
var columnName = property != null ? property.MappedColumnName : m.Member.Name;
return((alias != null ? alias + "." : "") + dialect.IdentifierEscapeStartCharacter + columnName + dialect.IdentifierEscapeEndCharacter);
}
if (m.Expression != null && Reflector.IsDataEntityList(m.Expression.Type, out elementType) && m.Member.Name == "Count")
{
var parentTable = ObjectFactory.GetTableName(typeof(T));
var childTable = ObjectFactory.GetTableName(elementType);
var parentPropertyMap = Reflector.GetPropertyMap(typeof(T));
var whereClause =
parentPropertyMap.Where(p => p.Value.IsPrimaryKey)
.Select(p => string.Format("{3}.{0}{2}{1} = {0}{4}{1}.{0}{2}{1}", dialect.IdentifierEscapeStartCharacter, dialect.IdentifierEscapeEndCharacter, p.Value.MappedColumnName, alias ?? (dialect.IdentifierEscapeStartCharacter + parentTable + dialect.IdentifierEscapeEndCharacter), childTable))
.ToDelimitedString(" AND ");
return(string.Format("(SELECT COUNT(*) FROM {0}{1}{2} WHERE {3})", dialect.IdentifierEscapeStartCharacter, childTable, dialect.IdentifierEscapeEndCharacter, whereClause));
}
var member = Expression.Convert(m, typeof(object));
var lambda = Expression.Lambda <Func <object> >(member);
var getter = lambda.Compile();
var o = getter();
return(GetQuotedValue(o, o.GetType()));
}
private static string VisitNewArray <T>(NewArrayExpression na, DialectProvider dialect, string alias)
{
var exprs = VisitExpressionList <T>(na.Expressions, dialect, alias);
var r = new StringBuilder();
foreach (var e in exprs)
{
r.Append(r.Length > 0 ? "," + e : e);
}
return(r.ToString());
}
internal static string GetTableNameForSql(Type objectType, DialectProvider dialect)
{
if (Reflector.IsEmitted(objectType))
{
objectType = Reflector.GetInterface(objectType);
}
if (AllTables.TryGetValue(Tuple.Create(objectType, dialect), out var tableName))
{
return(tableName);
}
var map = MappingFactory.GetEntityMap(objectType);
if (map != null)
{
tableName = dialect.IdentifierEscapeStartCharacter + map.TableName + dialect.IdentifierEscapeEndCharacter;
if (!string.IsNullOrEmpty(map.SchemaName))
{
tableName = dialect.IdentifierEscapeStartCharacter + map.SchemaName + dialect.IdentifierEscapeEndCharacter + "." + tableName;
}
}
if (tableName == null)
{
var attr = Reflector.GetAttribute <TableAttribute>(objectType);
if (attr != null)
{
tableName = dialect.IdentifierEscapeStartCharacter + attr.Name + dialect.IdentifierEscapeEndCharacter;
if (!string.IsNullOrEmpty(attr.SchemaName))
{
tableName = dialect.IdentifierEscapeStartCharacter + attr.SchemaName + dialect.IdentifierEscapeEndCharacter + "." + tableName;
}
}
}
if (tableName != null)
{
AllTables.TryAdd(Tuple.Create(objectType, dialect), tableName);
return(tableName);
}
tableName = objectType.Name;
if (objectType.IsInterface && tableName[0] == 'I')
{
tableName = tableName.Substring(1);
}
tableName = dialect.IdentifierEscapeStartCharacter + tableName + dialect.IdentifierEscapeEndCharacter;
AllTables.TryAdd(Tuple.Create(objectType, dialect), tableName);
return(tableName);
}
private static string VisitUnary <T>(UnaryExpression u, DialectProvider dialect, string alias)
{
switch (u.NodeType)
{
case ExpressionType.Not:
var o = Visit <T>(u.Operand, dialect, alias);
return("NOT (" + o + ")");
default:
return(Visit <T>(u.Operand, dialect, alias));
}
}
private static string VisitConstant(ConstantExpression c, DialectProvider dialect, string alias)
{
if (c.Value == null)
{
return("null");
}
if (c.Value is bool value)
{
return(value ? "(1=1)" : "(1=0)");
}
return(GetQuotedValue(c.Value, c.Value.GetType()));
}
private static string VisitConstant(ConstantExpression c, DialectProvider dialect, string alias)
{
if (c.Value == null)
{
return("null");
}
if (c.Value is bool)
{
var o = GetQuotedValue(c.Value, c.Value.GetType());
return(string.Format("({0}={1})", GetQuotedTrueValue(), o));
}
return(GetQuotedValue(c.Value, c.Value.GetType()));
}
private static string VisitLambda <T>(LambdaExpression lambda, DialectProvider dialect, string alias)
{
if (lambda.Body.NodeType == ExpressionType.MemberAccess)
{
var m = lambda.Body as MemberExpression;
if (m.Expression != null)
{
var r = VisitMemberAccess <T>(m, dialect, alias);
return(string.Format("{0}={1}", r, GetQuotedTrueValue()));
}
}
return(Visit <T>(lambda.Body, dialect, alias));
}
private static string VisitNew <T>(NewExpression nex, DialectProvider dialect, string alias)
{
// TODO : check !
var member = Expression.Convert(nex, typeof(object));
var lambda = Expression.Lambda <Func <object> >(member);
try
{
var getter = lambda.Compile();
var o = getter();
return(GetQuotedValue(o, o.GetType()));
}
catch (InvalidOperationException)
{
var exprs = VisitExpressionList <T>(nex.Arguments, dialect, alias);
var r = new StringBuilder();
foreach (var e in exprs)
{
r.AppendFormat("{0}{1}", r.Length > 0 ? "," : "", e);
}
return(r.ToString());
}
}
internal static string GetSelectAggregationStatement <T, TColumn>(string aggregateName, Expression <Func <T, TColumn> > projection, Expression <Func <T, bool> > predicate, DialectProvider dialect)
{
const string aliasRoot = "r";
var tableName = GetTableNameForSql(typeof(T), dialect) + " " + aliasRoot;
var whereClause = string.Empty;
if (predicate != null)
{
var evaluated = Evaluator.PartialEval(predicate);
evaluated = LocalCollectionExpander.Rewrite(evaluated);
var expression = PredicateVisitor.Visit <T>(evaluated, dialect, aliasRoot);
whereClause = string.Format(SqlWhereFormat, expression);
}
var memberExpression = (MemberExpression)projection.Body;
var parentPropertyMap = Reflector.GetPropertyMap(typeof(T));
parentPropertyMap.TryGetValue((PropertyInfo)memberExpression.Member, out var property);
var columnName = property != null ? property.MappedColumnName : memberExpression.Member.Name;
var sql = string.Format(SqlSelectAggregateFormat, aggregateName, dialect.IdentifierEscapeStartCharacter + columnName + dialect.IdentifierEscapeEndCharacter, tableName) + whereClause;
return(sql);
}
internal static string GetSelectCountStatement <T>(Expression <Func <T, bool> > predicate, DialectProvider dialect)
{
const string aliasRoot = "r";
var tableName = GetTableNameForSql(typeof(T), dialect) + " " + aliasRoot;
var whereClause = string.Empty;
if (predicate != null)
{
var evaluated = Evaluator.PartialEval(predicate);
evaluated = LocalCollectionExpander.Rewrite(evaluated);
var expression = PredicateVisitor.Visit <T>(evaluated, dialect, aliasRoot);
whereClause = string.Format(SqlWhereFormat, expression);
}
var sql = string.Format(SqlSelectCountFormat, tableName) + whereClause;
return(sql);
}
internal static string GetSelectStatement <T, T1, T2, T3>(Expression <Func <T, bool> > predicate, Expression <Func <T, T1, bool> > join1, Expression <Func <T1, T2, bool> > join2, Expression <Func <T2, T3, bool> > join3, int page, int pageSize, int skipCount, bool first, DialectProvider dialect, params Sorting <T>[] orderBy)
where T : class
where T1 : class
where T2 : class
where T3 : class
{
return(GetSelectStatement <T, T1, T2, T3, ObjectFactory.Fake>(predicate, join1, join2, join3, null, page, pageSize, skipCount, first, dialect, orderBy));
}
internal static string GetSelectStatement <T>(Expression <Func <T, bool> > predicate, int page, int pageSize, int skipCount, bool first, DialectProvider dialect, params Sorting <T>[] orderBy)
where T : class
{
return(GetSelectStatement <T, ObjectFactory.Fake, ObjectFactory.Fake, ObjectFactory.Fake, ObjectFactory.Fake>(predicate, null, null, null, null, page, pageSize, skipCount, first, dialect, orderBy));
}
internal static string GetSelectStatement <T, T1, T2, T3, T4>(Expression <Func <T, bool> > predicate, Expression <Func <T, T1, bool> > join1,
Expression <Func <T1, T2, bool> > join2, Expression <Func <T2, T3, bool> > join3, Expression <Func <T3, T4, bool> > join4,
int page, int pageSize, int skipCount, bool first, DialectProvider dialect, params Sorting <T>[] orderBy)
where T : class
where T1 : class
where T2 : class
where T3 : class
where T4 : class
{
const string aliasRoot = "r";
var fake = typeof(ObjectFactory.Fake);
var types = new Dictionary <Type, LambdaExpression>();
if (typeof(T1) != fake && join1 != null)
{
types.Add(typeof(T1), join1);
}
if (typeof(T2) != fake && join2 != null)
{
types.Add(typeof(T2), join2);
}
if (typeof(T3) != fake && join3 != null)
{
types.Add(typeof(T3), join3);
}
if (typeof(T4) != fake && join4 != null)
{
types.Add(typeof(T4), join4);
}
var mapRoot = Reflector.GetPropertyNameMap <T>();
var selection = mapRoot.Values.Where(p => p.IsSelectable && p.IsSimpleType).Select(p => aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + p.MappedColumnName + dialect.IdentifierEscapeEndCharacter).ToDelimitedString(",");
var tableName = GetTableNameForSql(typeof(T), dialect) + " " + aliasRoot;
var index = 1;
var mapJoinLast = mapRoot;
var aliasJoinLast = aliasRoot;
foreach (var type in types)
{
var aliasJoin = "t" + index;
var tableNameJoin = GetTableNameForSql(type.Key, dialect) + " " + aliasJoin;
var mapJoin = Reflector.GetPropertyNameMap(type.Key);
var binaryExpression = (BinaryExpression)type.Value.Body;
var left = (MemberExpression)binaryExpression.Left;
var right = (MemberExpression)binaryExpression.Right;
var op = GetOperator(binaryExpression.NodeType);
tableName += string.Format(SqlInnerJoinClauseFormat, tableNameJoin,
aliasJoinLast + "." + dialect.IdentifierEscapeStartCharacter + mapJoinLast[left.Member.Name].MappedColumnName + dialect.IdentifierEscapeEndCharacter, op,
aliasJoin + "." + dialect.IdentifierEscapeStartCharacter + mapJoin[right.Member.Name].MappedColumnName + dialect.IdentifierEscapeEndCharacter);
mapJoinLast = mapJoin;
aliasJoinLast = aliasJoin;
index++;
}
if (types.Count > 0)
{
selection = mapJoinLast.Values.Where(p => p.IsSelectable && p.IsSimpleType).Select(p => aliasJoinLast + "." + dialect.IdentifierEscapeStartCharacter + p.MappedColumnName + dialect.IdentifierEscapeEndCharacter).ToDelimitedString(",");
}
var sql = string.Empty;
var whereClause = string.Empty;
if (predicate != null)
{
var evaluated = Evaluator.PartialEval(predicate);
evaluated = LocalCollectionExpander.Rewrite(evaluated);
var expression = PredicateVisitor.Visit <T>(evaluated, dialect, aliasRoot);
whereClause = string.Format(SqlWhereFormat, expression);
}
if (skipCount > 0 || (page > 0 && pageSize > 0))
{
if (dialect is SqlServerLegacyDialectProvider)
{
if (orderBy.Length == 0)
{
var primaryKeyAscending = mapRoot.Keys.Where(p => mapRoot[p].IsPrimaryKey)
.Select(p => aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[p].MappedColumnName + dialect.IdentifierEscapeEndCharacter + " ASC")
.ToDelimitedString(",");
var primaryKeyDescending = mapRoot.Keys.Where(p => mapRoot[p].IsPrimaryKey)
.Select(p => aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[p].MappedColumnName + dialect.IdentifierEscapeEndCharacter + " DESC")
.ToDelimitedString(",");
if (page > 0 && pageSize > 0)
{
sql = string.Format(SqlSelectPagingFormatMssqlLegacy, tableName, selection, primaryKeyAscending, primaryKeyDescending, whereClause, pageSize, page * pageSize);
}
else
{
throw new NotSupportedException();
}
}
else
{
var sort = new StringBuilder();
var sortReverse = new StringBuilder();
foreach (var o in orderBy)
{
var column = aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[((MemberExpression)o.OrderBy.Body).Member.Name].MappedColumnName + dialect.IdentifierEscapeEndCharacter;
sort.AppendFormat("{0} {1}, ", column, !o.Reverse ? "ASC" : "DESC");
sortReverse.AppendFormat("{0} {1}, ", column, !o.Reverse ? "DESC" : "ASC");
}
sort.Length -= 2;
sortReverse.Length -= 2;
if (page > 0 && pageSize > 0)
{
sql = string.Format(SqlSelectPagingFormatMssqlLegacy, tableName, selection, sort, sortReverse, whereClause, pageSize, page * pageSize);
}
else
{
throw new NotSupportedException();
}
}
}
else if (dialect is SqlServerDialectProvider || dialect is OracleDialectProvider)
{
var selectionWithoutAlias =
mapRoot.Values.Where(p => p.IsSelectable && p.IsSimpleType).Select(p => dialect.IdentifierEscapeStartCharacter + p.MappedColumnName + dialect.IdentifierEscapeEndCharacter).ToDelimitedString(",");
if (orderBy.Length == 0)
{
var primaryKey =
mapRoot.Keys.Where(p => mapRoot[p].IsPrimaryKey)
.Select(p => aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[p].MappedColumnName + dialect.IdentifierEscapeEndCharacter)
.ToDelimitedString(",");
if (page > 0 && pageSize > 0)
{
sql = string.Format(SqlSelectPagingFormatRowNumber, tableName, selection, primaryKey, whereClause, (page - 1) * pageSize, page * pageSize, selectionWithoutAlias);
}
else
{
sql = string.Format(SqlSelectSkipFormatRowNumber, tableName, selection, primaryKey, whereClause, skipCount, selectionWithoutAlias);
}
}
else
{
var sort = new StringBuilder();
foreach (var o in orderBy)
{
var column = aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[((MemberExpression)o.OrderBy.Body).Member.Name].MappedColumnName + dialect.IdentifierEscapeEndCharacter;
sort.AppendFormat("{0} {1}, ", column, !o.Reverse ? "ASC" : "DESC");
}
sort.Length -= 2;
if (page > 0 && pageSize > 0)
{
sql = string.Format(SqlSelectPagingFormatRowNumber, tableName, selection, sort, whereClause, (page - 1) * pageSize, page * pageSize, selectionWithoutAlias);
}
else
{
sql = string.Format(SqlSelectSkipFormatRowNumber, tableName, selection, sort, whereClause, skipCount, selectionWithoutAlias);
}
}
}
else if (dialect is SqlServerLatestDialectProvider)
{
if (orderBy.Length == 0)
{
var primaryKey =
mapRoot.Keys.Where(p => mapRoot[p].IsPrimaryKey)
.Select(p => aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[p].MappedColumnName + dialect.IdentifierEscapeEndCharacter)
.ToDelimitedString(",");
if (page > 0 && pageSize > 0)
{
sql = string.Format(SqlSelectPagingWithOrderByFormat, tableName, selection, whereClause, primaryKey, whereClause, (page - 1) * pageSize, pageSize);
}
else
{
sql = string.Format(SqlSelectSkipWithOrderByFormat, tableName, selection, whereClause, primaryKey, skipCount);
}
}
else
{
var sort = new StringBuilder();
foreach (var o in orderBy)
{
var column = aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[((MemberExpression)o.OrderBy.Body).Member.Name].MappedColumnName + dialect.IdentifierEscapeEndCharacter;
sort.AppendFormat("{0} {1}, ", column, !o.Reverse ? "ASC" : "DESC");
}
sort.Length -= 2;
if (page > 0 && pageSize > 0)
{
sql = string.Format(SqlSelectPagingWithOrderByFormat, tableName, selection, whereClause, sort, (page - 1) * pageSize, pageSize);
}
else
{
sql = string.Format(SqlSelectSkipWithOrderByFormat, tableName, selection, whereClause, sort, skipCount);
}
}
}
else
{
var orderByClause = "";
if (orderBy.Length > 0)
{
var sort = new StringBuilder(" ORDER BY ");
foreach (var o in orderBy)
{
var column = aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[((MemberExpression)o.OrderBy.Body).Member.Name].MappedColumnName + dialect.IdentifierEscapeEndCharacter;
sort.AppendFormat("{0} {1}, ", column, !o.Reverse ? "ASC" : "DESC");
}
sort.Length -= 2;
orderByClause = sort.ToString();
}
if (page > 0 && pageSize > 0)
{
sql = string.Format(SqlSelectPagingFormat, tableName, selection, whereClause, orderByClause, pageSize, (page - 1) * pageSize);
}
else
{
sql = string.Format(SqlSelectSkipFormat, tableName, selection, whereClause, orderByClause, skipCount);
}
}
}
else
{
sql = string.Format(SqlSelectFormat, tableName, selection) + whereClause;
if (orderBy.Length > 0)
{
var sort = new StringBuilder(" ORDER BY ");
foreach (var o in orderBy)
{
var column = aliasRoot + "." + dialect.IdentifierEscapeStartCharacter + mapRoot[((MemberExpression)o.OrderBy.Body).Member.Name].MappedColumnName + dialect.IdentifierEscapeEndCharacter;
sort.AppendFormat("{0} {1}, ", column, !o.Reverse ? "ASC" : "DESC");
}
sort.Length -= 2;
sql += sort;
}
}
if (first)
{
if (dialect is SqlServerDialectProvider)
{
sql = string.Format(SqlSelectFirstFormatMssql, sql);
}
else if (dialect is OracleDialectProvider)
{
sql = string.Format(SqlSelectFirstFormatOracle, sql);
}
else
{
sql = string.Format(SqlSelectFirstFormat, sql);
}
}
return(sql);
}
internal static string GetUpdateStatement(Type objectType, IList <Param> parameters, IList <Param> primaryKey, DialectProvider dialect)
{
var tableName = GetTableNameForSql(objectType, dialect);
var columns = parameters.Select(p => string.Format(SqlSetFormat, p.Source, dialect.ParameterPrefix + p.Name, dialect.IdentifierEscapeStartCharacter, dialect.IdentifierEscapeEndCharacter)).ToDelimitedString(",");
var where = primaryKey.Select(p => string.Format(SqlSetFormat, p.Source, dialect.ParameterPrefix + p.Name, dialect.IdentifierEscapeStartCharacter, dialect.IdentifierEscapeEndCharacter)).ToDelimitedString(" AND ");
var sql = string.Format(SqlUpdateFormat, tableName, columns, where);
return(sql);
}
private static List <Object> VisitExpressionList <T>(ReadOnlyCollection <Expression> original, DialectProvider dialect, string alias)
{
var list = new List <Object>();
for (int i = 0, n = original.Count; i < n; i++)
{
if (original[i].NodeType == ExpressionType.NewArrayInit || original[i].NodeType == ExpressionType.NewArrayBounds)
{
list.AddRange(VisitNewArrayFromExpressionList <T>(original[i] as NewArrayExpression, dialect, alias));
}
else
{
list.Add(Visit <T>(original[i], dialect, alias));
}
}
return(list);
}
private static string VisitMethodCall <T>(MethodCallExpression m, DialectProvider dialect, string alias)
{
var args = VisitExpressionList <T>(m.Arguments, dialect, alias);
object r;
if (m.Object != null)
{
r = Visit <T>(m.Object, dialect, alias);
}
else
{
r = args[0];
args.RemoveAt(0);
}
switch (m.Method.Name)
{
case "ToUpper":
return(string.Format("upper({0})", r));
case "ToLower":
return(string.Format("lower({0})", r));
case "StartsWith":
return(string.Format("upper({0}) like '{1}%' ", r, RemoveQuote(args[0].ToString()).ToUpper()));
case "EndsWith":
return(string.Format("upper({0}) like '%{1}'", r, RemoveQuote(args[0].ToString()).ToUpper()));
case "Contains":
return(string.Format("upper({0}) like '%{1}%'", r, RemoveQuote(args[0].ToString()).ToUpper()));
case "Substring":
var startIndex = Int32.Parse(args[0].ToString()) + 1;
if (args.Count == 2)
{
var length = Int32.Parse(args[1].ToString());
return(string.Format(dialect.SubstringFunction + "({0}, {1}, {2})", r, startIndex, length));
}
return(string.Format(dialect.SubstringFunction + "({0}, {1})", r, startIndex));
case "Round":
case "Floor":
case "Ceiling":
case "Coalesce":
case "Abs":
case "Sum":
return(string.Format("{0}({1}{2})",
m.Method.Name,
r,
args.Count == 1 ? string.Format(",{0}", args[0]) : ""));
case "Concat":
if (dialect.StringConcatenationFunction != null)
{
var s = new StringBuilder();
s.Append(dialect.StringConcatenationFunction);
s.Append("(");
for (var i = 0; i < args.Count; i++)
{
s.AppendFormat("{0}", args[i]);
if (i != args.Count - 1)
{
s.AppendFormat(",");
}
}
s.Append(")");
return(string.Format("{0}{1}", r, s));
}
else
{
var s = new StringBuilder();
foreach (var e in args)
{
s.AppendFormat(" {0} {1}", dialect.StringConcatenationOperator, e);
}
return(string.Format("{0}{1}", r, s));
}
case "In":
var member = Expression.Convert(m.Arguments[1], typeof(object));
var lambda = Expression.Lambda <Func <object> >(member);
var getter = lambda.Compile();
var inArgs = getter() as object[];
var sIn = new StringBuilder();
foreach (var e in inArgs)
{
if (e.GetType().ToString() != "System.Collections.Generic.List`1[System.Object]")
{
sIn.AppendFormat("{0}{1}", sIn.Length > 0 ? "," : "", GetQuotedValue(e, e.GetType()));
}
else
{
var listArgs = e as IList <object>;
foreach (var el in listArgs)
{
sIn.AppendFormat("{0}{1}", sIn.Length > 0 ? "," : "", GetQuotedValue(el, el.GetType()));
}
}
}
return(string.Format("{0} {1} ({2})", r, m.Method.Name, sIn));
case "Desc":
return(string.Format("{0} DESC", r));
case "As":
return(string.Format("{0} As [{1}]", r, RemoveQuote(args[0].ToString())));
case "ToString":
return(r.ToString());
default:
var s2 = new StringBuilder();
foreach (var e in args)
{
s2.AppendFormat(",{0}", GetQuotedValue(e, e.GetType()));
}
return(string.Format("{0}({1}{2})", m.Method.Name, r, s2));
}
}
private static string VisitParameter(ParameterExpression p, DialectProvider dialect, string alias)
{
return(p.Name);
}
internal static string GetInsertStatement(Type objectType, Param[] parameters, DialectProvider dialect)
{
var tableName = GetTableNameForSql(objectType, dialect);
var columns = parameters.Where(p => !p.IsAutoGenerated).Select(p => dialect.IdentifierEscapeStartCharacter + p.Source + dialect.IdentifierEscapeEndCharacter).ToDelimitedString(",");
var paramNames = parameters.Where(p => !p.IsAutoGenerated).Select(p => dialect.UseOrderedParameters ? "?" : dialect.ParameterPrefix + p.Name).ToDelimitedString(",");
var sql = string.Format(SqlInsertFormat, tableName, columns, paramNames);
var primaryKey = parameters.FirstOrDefault(p => p.IsAutoGenerated && p.IsPrimaryKey);
if (primaryKey != null)
{
sql += ";" + dialect.ComputeAutoIncrement(primaryKey.Name, () => tableName);
}
return(sql);
}
private static string VisitBinary <T>(BinaryExpression b, DialectProvider dialect, string alias)
{
string left, right;
var operand = BindOperant(b.NodeType);
if (operand == "AND" || operand == "OR")
{
var m = b.Left as MemberExpression;
if (m != null && m.Expression != null)
{
string r = VisitMemberAccess <T>(m, dialect, alias);
left = string.Format("{0}={1}", r, GetQuotedTrueValue());
}
else
{
left = Visit <T>(b.Left, dialect, alias);
}
m = b.Right as MemberExpression;
if (m != null && m.Expression != null)
{
string r = VisitMemberAccess <T>(m, dialect, alias);
right = string.Format("{0}={1}", r, GetQuotedTrueValue());
}
else
{
right = Visit <T>(b.Right, dialect, alias);
}
}
else
{
left = Visit <T>(b.Left, dialect, alias);
right = Visit <T>(b.Right, dialect, alias);
}
if (operand == "=" && right == "null")
{
operand = "is";
}
else if (operand == "<>" && right == "null")
{
operand = "is not";
}
else if (operand == "=" || operand == "<>")
{
if (IsTrueExpression(right))
{
right = GetQuotedTrueValue();
}
else if (IsFalseExpression(right))
{
right = GetQuotedFalseValue();
}
if (IsTrueExpression(left))
{
left = GetQuotedTrueValue();
}
else if (IsFalseExpression(left))
{
left = GetQuotedFalseValue();
}
}
switch (operand)
{
case "MOD":
case "COALESCE":
return(string.Format("{0}({1},{2})", operand, left, right));
default:
return(left + " " + operand + " " + right);
}
}
internal static string Visit <T>(Expression exp, DialectProvider dialect, string alias)
{
if (exp == null)
{
return(string.Empty);
}
switch (exp.NodeType)
{
case ExpressionType.Lambda:
return(VisitLambda <T>(exp as LambdaExpression, dialect, alias));
case ExpressionType.MemberAccess:
return(VisitMemberAccess <T>(exp as MemberExpression, dialect, alias));
case ExpressionType.Constant:
return(VisitConstant(exp as ConstantExpression, dialect, alias));
case ExpressionType.Add:
case ExpressionType.AddChecked:
case ExpressionType.Subtract:
case ExpressionType.SubtractChecked:
case ExpressionType.Multiply:
case ExpressionType.MultiplyChecked:
case ExpressionType.Divide:
case ExpressionType.Modulo:
case ExpressionType.And:
case ExpressionType.AndAlso:
case ExpressionType.Or:
case ExpressionType.OrElse:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.Equal:
case ExpressionType.NotEqual:
case ExpressionType.Coalesce:
case ExpressionType.ArrayIndex:
case ExpressionType.RightShift:
case ExpressionType.LeftShift:
case ExpressionType.ExclusiveOr:
return("(" + VisitBinary <T>(exp as BinaryExpression, dialect, alias) + ")");
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
case ExpressionType.Not:
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
case ExpressionType.ArrayLength:
case ExpressionType.Quote:
case ExpressionType.TypeAs:
return(VisitUnary <T>(exp as UnaryExpression, dialect, alias));
case ExpressionType.Parameter:
return(VisitParameter(exp as ParameterExpression, dialect, alias));
case ExpressionType.Call:
return(VisitMethodCall <T>(exp as MethodCallExpression, dialect, alias));
case ExpressionType.New:
return(VisitNew <T>(exp as NewExpression, dialect, alias));
case ExpressionType.NewArrayInit:
case ExpressionType.NewArrayBounds:
return(VisitNewArray <T>(exp as NewArrayExpression, dialect, alias));
default:
return(exp.ToString());
}
}
internal static string GetDeleteStatement(Type objectType, IList <Param> primaryKey, DialectProvider dialect, string softDeleteColumn = null)
{
var tableName = GetTableNameForSql(objectType, dialect);
var where = primaryKey.Select(p => string.Format(SqlSetFormat, p.Source, dialect.ParameterPrefix + p.Name, dialect.IdentifierEscapeStartCharacter, dialect.IdentifierEscapeEndCharacter)).ToDelimitedString(" AND ");
var sql = !string.IsNullOrEmpty(softDeleteColumn) ? string.Format(SqlSoftDeleteFormat, tableName, softDeleteColumn, @where) : string.Format(SqlDeleteFormat, tableName, @where);
return(sql);
}
private static IEnumerable <object> VisitNewArrayFromExpressionList <T>(NewArrayExpression na, DialectProvider dialect, string alias)
{
var exprs = VisitExpressionList <T>(na.Expressions, dialect, alias);
return(exprs);
}
