private ISelectQueryAble <T> SelectParser(Expression expression, Expression expressionBody, params Type[] types)
{
_SqlBuilder.SetSqlCommandType(SqlCommandType.Select);
_SqlBuilder.SetTableAlias(_MainTableName);
_SqlBuilder.AppendSelectSql($"SELECT {{0}} FROM {_MainTableName} {_SqlBuilder.GetTableAlias(_MainTableName)} ");
var selectQueryAble = new SelectQueryAble <T>(_SqlBuilder, _DapperKitProvider);
if (expression != null && expressionBody != null)
{
if (types != null && types.Length > 0)
{
_SqlBuilder.SetSelectMultiTable();
foreach (var type in types)
{
string tableName = type.GetDapperTableName(_SqlBuilder._SqlFormater);
_SqlBuilder.SetTableAlias(tableName);
//add data table type to collection
selectQueryAble.TableTypeCollections.Add(type);
}
}
SqlVistorProvider.Select(expressionBody, _SqlBuilder);
}
else
{
_SqlBuilder.AddSelectColumn("* ");
_SqlBuilder.AddSelectPageColumn("* ");
}
return(selectQueryAble);
}
private SelectQueryAble <T> JoinParser(Expression expression, Expression expressionBody, JoinType joinType, params Type[] types)
{
if (expression != null && expressionBody != null)
{
foreach (var type in types)
{
if (!TableTypeCollections.Contains(type))
{
var tableName = types[types.Length - 1].GetDapperTableName(SqlBuilder._SqlFormater);
throw new Exception($"select query tables can not found {tableName}");
}
}
var joinStr = string.Empty;
if (joinType != JoinType.NONE)
{
joinStr = joinType.ToString();
}
var joinTableName = types[types.Length - 1].GetDapperTableName(SqlBuilder._SqlFormater);
var joinTableAlias = SqlBuilder.GetTableAlias(joinTableName);
SqlBuilder.AppendJoinSql($"{joinStr} JOIN {(joinTableName + " " + joinTableAlias)} ON ");
SqlVistorProvider.Join(expressionBody, SqlBuilder);
}
return(this);
}
public IUpdateQueryAble <T> Where(Expression <Func <T, bool> > expression)
{
Check.Argument.IsNotNull(expression, nameof(expression));
SqlVistorProvider.Where(expression.Body, SqlBuilder);
return(this);
}
public ICalculateQueryAble <T> Min(Expression <Func <T, object> > expression)
{
Check.Argument.IsNotNull(expression, nameof(expression));
_SqlBuilder.SetSqlCommandType(SqlCommandType.Calculate);
_SqlBuilder.AppendCalculateSql($"SELECT {{0}} FROM {_MainTableName} ");
SqlVistorProvider.Min(expression.Body, _SqlBuilder);
return(new CalculateQueryAble <T>(_SqlBuilder, _DapperKitProvider));
}
/// <summary>
/// update
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public IUpdateQueryAble <T> Update(Expression <Func <T> > expression)
{
Check.Argument.IsNotNull(expression, nameof(expression));
_SqlBuilder.SetSqlCommandType(SqlCommandType.Update);
_SqlBuilder.AppendUpdateSql($"UPDATE {_MainTableName} SET ");
SqlVistorProvider.Update(expression.Body, _SqlBuilder);
return(new UpdateQueryAble <T>(_SqlBuilder, _DapperKitProvider));
}
/// <summary>
/// delete
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public IDeleteQueryAble <T> Delete(Expression <Func <T, bool> > expression = null)
{
_SqlBuilder.AppendDeleteSql($"DELETE {_MainTableName} ");
_SqlBuilder.SetSqlCommandType(SqlCommandType.Delete);
if (expression != null)
{
SqlVistorProvider.Delete(expression.Body, _SqlBuilder);
}
return(new DeleteQueryAble <T>(_SqlBuilder, _DapperKitProvider));
}
/// <summary>
/// insert
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public IInsertQueryAble <T> Insert(Expression <Func <T> > expression)
{
Check.Argument.IsNotNull(expression, nameof(expression));
_SqlBuilder.SetSqlCommandType(SqlCommandType.Insert);
_SqlBuilder.AppendInsertSql($"INSERT INTO {_MainTableName} ");
SqlVistorProvider.Insert(expression.Body, _SqlBuilder);
return(new InsertQueryAble <T>(_SqlBuilder, _DapperKitProvider));
}
public ICalculateQueryAble <T> Count(Expression <Func <T, object> > expression = null)
{
_SqlBuilder.SetSqlCommandType(SqlCommandType.Calculate);
_SqlBuilder.AppendCalculateSql($"SELECT {{0}} FROM {_MainTableName} ");
if (expression != null)
{
SqlVistorProvider.Count(expression.Body, _SqlBuilder);
}
else
{
_SqlBuilder.AddCalculateColumn("COUNT(*) ");
}
return(new CalculateQueryAble <T>(_SqlBuilder, _DapperKitProvider));
}
public static void SetDbProvider(SqlVistorProvider sqlProvider)
{
_sqlProvider = sqlProvider;
}
public ICalculateQueryAble <T> GroupBy(Expression <Func <T, object> > expression)
{
Check.Argument.IsNotNull(expression, nameof(expression));
SqlVistorProvider.GroupBy(expression.Body, SqlBuilder);
return(this);
}
public IOrderQueryAble <T> ThenByDescending(Expression <Func <T, object> > expression)
{
Check.Argument.IsNotNull(expression, nameof(expression));
SqlVistorProvider.ThenByDescending(expression.Body, SqlBuilder);
return(this);
}
public IOrderQueryAble <T> OrderByDescending(Expression <Func <T, object> > expression)
{
Check.Argument.IsNotNull(expression, nameof(expression));
SqlVistorProvider.OrderByDescending(expression.Body, SqlBuilder);
return(new OrderQueryAble <T>(SqlBuilder, DapperKitProvider));
}
