/// <summary>
/// 创建 SQL 命令
/// </summary>
/// <param name="query">查询 语句</param>
/// <returns></returns>
public CommandDefine Parse <T>(IDbQueryable <T> query)
{
IDbQueryableInfo <T> info = DbQueryParser.Parse(query);
DbQueryableInfo_Select <T> qQuery = info as DbQueryableInfo_Select <T>;
if (qQuery != null)
{
return(this.ParseSelectCommand <T>(qQuery));
}
DbQueryableInfo_Insert <T> qInsert = info as DbQueryableInfo_Insert <T>;
if (qInsert != null)
{
return(this.ParseInsertCommand <T>(qInsert));
}
DbQueryableInfo_Update <T> qUpdate = info as DbQueryableInfo_Update <T>;
if (qUpdate != null)
{
return(this.ParseUpdateCommand <T>(qUpdate));
}
DbQueryableInfo_Delete <T> qDelete = info as DbQueryableInfo_Delete <T>;
if (qDelete != null)
{
return(this.ParseDeleteCommand <T>(qDelete));
}
throw new NotImplementedException();
}
/// <summary>
/// 创建 SQL 命令
/// </summary>
/// <param name="dbQuery">查询 语句</param>
/// <param name="indent">缩进</param>
/// <param name="isOuter">是否最外层，内层查询不需要结束符(;)</param>
/// <param name="token">解析上下文参数</param>
/// <returns></returns>
public RawCommand Resolve <T>(IDbQueryable <T> dbQuery, int indent, bool isOuter, ResolveToken token)
{
// 参数化设置
if (token == null)
{
token = new ResolveToken();
}
if (!dbQuery.HasSetParameterized)
{
dbQuery.Parameterized = true;
}
if (!token.HasSetParameterized)
{
token.Parameterized = dbQuery.Parameterized;
}
if (token.Parameterized && token.Parameters == null)
{
token.Parameters = new List <IDbDataParameter>(8);
}
if (token.DbContext == null)
{
token.DbContext = dbQuery.DbContext;
}
// 解析查询语义
IDbQueryableInfo result = DbQueryParser.Parse <T>(dbQuery);
// 查询
var result_Query = result as IDbQueryableInfo_Select;
if (result_Query != null)
{
return(this.ResolveSelectCommand(result_Query, indent, isOuter, token));
}
// 新增
var result_Insert = result as IDbQueryableInfo_Insert;
if (result_Insert != null)
{
return(this.ResolveInsertCommand <T>(result_Insert, token));
}
// 更新
var result_Update = result as IDbQueryableInfo_Update;
if (result_Update != null)
{
return(this.ResolveUpdateCommand <T>(result_Update, token));
}
// 删除
var result_Delete = result as IDbQueryableInfo_Delete;
if (result_Delete != null)
{
return(this.ResolveDeleteCommand <T>(result_Delete, token));
}
throw new NotImplementedException();
}
/// <summary>
/// 创建 SQL 命令
/// </summary>
/// <param name="dbQueryable">查询 语句</param>
/// <param name="indent">缩进</param>
/// <param name="isOuter">是否最外层，内层查询不需要结束符(;)</param>
/// <param name="token">解析上下文参数</param>
/// <returns></returns>
public Command Resolve <T>(IDbQueryable <T> dbQueryable, int indent, bool isOuter, ResolveToken token)
{
// 设置该查询是否需要参数化
if (token == null)
{
token = new ResolveToken();
}
if (!((DbQueryable)dbQueryable).HasSetParameterized)
{
dbQueryable.Parameterized = true;
}
if (dbQueryable.Parameterized && token.Parameters == null)
{
token.Parameters = new List <IDbDataParameter>(8);
}
// 调试模式
if (token != null && !token.HasSetIsDebug)
{
token.IsDebug = dbQueryable.DbContext.IsDebug;
}
// 解析查询语义
IDbQueryableInfo <T> dbQueryInfo = DbQueryParser.Parse(dbQueryable);
DbQueryableInfo_Select <T> sQueryInfo = dbQueryInfo as DbQueryableInfo_Select <T>;
if (sQueryInfo != null)
{
return(this.ParseSelectCommand <T>(sQueryInfo, indent, isOuter, token));
}
DbQueryableInfo_Insert <T> nQueryInfo = dbQueryInfo as DbQueryableInfo_Insert <T>;
if (nQueryInfo != null)
{
return(this.ParseInsertCommand <T>(nQueryInfo, token));
}
DbQueryableInfo_Update <T> uQueryInfo = dbQueryInfo as DbQueryableInfo_Update <T>;
if (uQueryInfo != null)
{
return(this.ParseUpdateCommand <T>(uQueryInfo, token));
}
DbQueryableInfo_Delete <T> dQueryInfo = dbQueryInfo as DbQueryableInfo_Delete <T>;
if (dQueryInfo != null)
{
return(this.ParseDeleteCommand <T>(dQueryInfo, token));
}
throw new NotImplementedException();
}
/// <summary>
/// 创建 SQL 命令
/// </summary>
/// <param name="dbQuery">查询 语句</param>
/// <param name="indent">缩进</param>
/// <param name="isOuter">是否最外层，内层查询不需要结束符(;)</param>
/// <param name="token">解析上下文参数</param>
/// <returns></returns>
public Command Resolve <T>(IDbQueryable <T> dbQuery, int indent, bool isOuter, ResolveToken token)
{
// 设置该查询是否需要参数化
if (token == null)
{
token = new ResolveToken();
}
if (!((DbQueryable)dbQuery).HasSetParameterized)
{
dbQuery.Parameterized = true;
}
if (dbQuery.Parameterized && token.Parameters == null)
{
token.Parameters = new List <IDbDataParameter>(8);
}
// 调试模式
if (token != null && !token.HasSetIsDebug)
{
token.IsDebug = dbQuery.DbContext.IsDebug;
}
// 解析查询语义
IDbQueryableInfo <T> result = DbQueryParser.Parse(dbQuery);
// 查询
DbQueryableInfo_Select <T> result_Query = result as DbQueryableInfo_Select <T>;
if (result_Query != null)
{
return(this.ResolveSelectCommand <T>(result_Query, indent, isOuter, token));
}
// 新增
DbQueryableInfo_Insert <T> result_Insert = result as DbQueryableInfo_Insert <T>;
if (result_Insert != null)
{
return(this.ResolveInsertCommand <T>(result_Insert, token));
}
// 更新
DbQueryableInfo_Update <T> result_Update = result as DbQueryableInfo_Update <T>;
if (result_Update != null)
{
return(this.ResolveUpdateCommand <T>(result_Update, token));
}
// 删除
DbQueryableInfo_Delete <T> result_Delete = result as DbQueryableInfo_Delete <T>;
if (result_Delete != null)
{
return(this.ResolveDeleteCommand <T>(result_Delete, token));
}
throw new NotImplementedException();
}
/// <summary>
/// 创建 SQL 命令
/// </summary>
/// <param name="dbQueryable">查询 语句</param>
/// <param name="indent">缩进</param>
/// <param name="isOuter">是否最外层，内层查询不需要结束符(;)</param>
/// <param name="parameters">已存在的参数列表</param>
/// <returns></returns>
public DbCommandDefinition Resolve <T>(IDbQueryable <T> dbQueryable, int indent = 0, bool isOuter = true, List <IDbDataParameter> parameters = null)
{
// 设置该查询是否需要参数化
if (!((DbQueryable)dbQueryable).HasSetParameterized)
{
dbQueryable.Parameterized = true;
}
if (dbQueryable.Parameterized && parameters == null)
{
parameters = new List <IDbDataParameter>(8);
}
// 解析查询语义
IDbQueryableInfo <T> info = DbQueryParser.Parse(dbQueryable);
DbQueryableInfo_Select <T> sQuery = info as DbQueryableInfo_Select <T>;
if (sQuery != null)
{
return(this.ParseSelectCommand <T>(sQuery, indent, isOuter, dbQueryable.Parameterized ? parameters : null));
}
DbQueryableInfo_Insert <T> nQuery = info as DbQueryableInfo_Insert <T>;
if (nQuery != null)
{
return(this.ParseInsertCommand <T>(nQuery, dbQueryable.Parameterized ? parameters : null));
}
DbQueryableInfo_Update <T> uQuery = info as DbQueryableInfo_Update <T>;
if (uQuery != null)
{
return(this.ParseUpdateCommand <T>(uQuery, dbQueryable.Parameterized ? parameters : null));
}
DbQueryableInfo_Delete <T> dQuery = info as DbQueryableInfo_Delete <T>;
if (dQuery != null)
{
return(this.ParseDeleteCommand <T>(dQuery, dbQueryable.Parameterized ? parameters : null));
}
throw new NotImplementedException();
}
