/// <summary>
/// 执行非查询指令
/// </summary>
/// <param name="sql">sql语句</param>
/// <param name="parameters">查询参数</param>
/// <param name="hints">指令参数：如timeout</param>
/// <param name="operationType">操作类型，读写分离，默认从master库读取</param>
/// <returns>影响行数</returns>
/// <exception cref="DalException">数据访问框架异常</exception>
public Int32 ExecNonQuery(String sql, StatementParameterCollection parameters, IDictionary hints, OperationType operationType)
{
try
{
Int32 result;
if (!IsShardEnabled)
{
Statement statement = SqlBuilder.GetNonQueryStatement(LogicDbName, ShardingStrategy, sql, parameters, hints, operationType).Single();
AddSqlToExtendParams(statement, hints);
result = DatabaseBridge.Instance.ExecuteNonQuery(statement);
}
else
{
var statements = ShardingUtil.GetShardStatement(LogicDbName, ShardingStrategy, parameters, hints,
newHints => SqlBuilder.GetNonQueryStatement(LogicDbName, ShardingStrategy, sql, parameters, newHints, operationType, SqlStatementType.UNKNOWN), SqlStatementType.UNKNOWN);
result = ShardingExecutor.ExecuteShardingNonQuery(statements).Sum();
}
return(result);
}
catch (Exception ex)
{
throw;
}
finally
{
}
}
/// <summary>
///
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="parameters">查询参数</param>
/// <param name="hints">指令的扩展属性</param>
/// <param name="operationType">操作类型，读写分离，默认从master库读取</param>
/// <returns>DataSet</returns>
/// <exception cref="DalException">数据访问框架异常</exception>
public DataSet SelectDataSet(String sql, StatementParameterCollection parameters, IDictionary hints, OperationType operationType)
{
try
{
DataSet dataSet;
if (!IsShardEnabled)
{
Statement statement = SqlBuilder.GetSqlStatement(LogicDbName, ShardingStrategy, sql, parameters,
hints, operationType).Single();
AddSqlToExtendParams(statement, hints);
dataSet = DatabaseBridge.Instance.ExecuteDataSet(statement);
}
else
{
var statements = ShardingUtil.GetShardStatement(LogicDbName, ShardingStrategy, null, hints, newHints => ShardingUtil.GetQueryStatement(LogicDbName, sql, ShardingStrategy, parameters, newHints, operationType), SqlStatementType.SELECT);
dataSet = ShardingExecutor.ExecuteShardingDataSet(statements);
}
return(dataSet);
}
catch (Exception ex)
{
throw;
}
finally
{
}
}
/// <summary>
/// 执行查询语句
/// </summary>
/// <param name="sql">sql语句</param>
/// <param name="parameters">查询参数</param>
/// <param name="hints">指令扩展属性</param>
/// <param name="operationType">操作类型，读写分离，默认从master库读取</param>
/// <returns>IDataReader</returns>
/// <exception cref="DalException">数据访问框架异常</exception>
public IList <IDataReader> SelectDataReader(String sql, StatementParameterCollection parameters, IDictionary hints, OperationType operationType)
{
try
{
if (!IsShardEnabled)
{
Statement statement = SqlBuilder.GetSqlStatement(LogicDbName, ShardingStrategy, sql, parameters, hints, operationType).Single();
AddSqlToExtendParams(statement, hints);
return(new List <IDataReader> {
DatabaseBridge.Instance.ExecuteReader(statement)
});
}
else
{
var statements = ShardingUtil.GetShardStatement(LogicDbName, ShardingStrategy, parameters, hints, newHints => ShardingUtil.GetQueryStatement(LogicDbName, sql, ShardingStrategy, parameters, newHints, operationType), SqlStatementType.SELECT);
return(ShardingExecutor.GetShardingDataReaderList(statements));
}
}
catch (Exception ex)
{
throw;
}
finally
{
}
}
/// <summary>
/// 执行查询语句
/// </summary>
/// <param name="sql">sql语句</param>
/// <param name="parameters">查询参数</param>
/// <param name="hints">指令扩展属性</param>
/// <param name="operationType">操作类型，读写分离，默认从master库读取</param>
/// <returns>IDataReader</returns>
/// <exception cref="DalException">数据访问框架异常</exception>
public IList <IDataReader> SelectDataReader(String sql, StatementParameterCollection parameters, IDictionary hints, OperationType operationType)
{
if (!IsShardEnabled)
{
Statement statement = SqlBuilder.GetSqlStatement(LogicDbName, ShardingStrategy, sql, parameters, hints, operationType).Single();
AddSqlToExtendParams(statement, hints);
try
{
var reader = DatabaseBridge.Instance.ExecuteReader(statement);
return(new List <IDataReader> {
reader
});
}
finally
{
RunTimeDetail runTimeDetail = new RunTimeDetail
{
DbName = statement.DbName,
Duration = statement.Duration,
Server = statement.HostName
};
if (hints != null)
{
hints.Add(DALExtStatementConstant.EXCUTE_TIME, new List <RunTimeDetail> {
runTimeDetail
});
}
}
}
else
{
var statements = ShardingUtil.GetShardStatement(LogicDbName, ShardingStrategy, parameters, hints, newHints => ShardingUtil.GetQueryStatement(LogicDbName, sql, ShardingStrategy, parameters, newHints, operationType), SqlStatementType.SELECT);
try
{
var reader = ShardingExecutor.GetShardingDataReaderList(statements);
return(reader);
}
finally
{
var runTimeList = new List <RunTimeDetail>();
foreach (var statement in statements)
{
RunTimeDetail runTimeDetail = new RunTimeDetail
{
DbName = statement.DbName,
Duration = statement.Duration,
Server = statement.HostName
};
runTimeList.Add(runTimeDetail);
}
if (hints != null)
{
hints.Add(DALExtStatementConstant.EXCUTE_TIME, runTimeList);
}
}
}
}
private static List <Statement> GetDefaultSqlStatement(String logicDbName, IShardingStrategy shardingStrategy,
String sql, StatementParameterCollection parameters, IDictionary hints, SqlStatementType sqlType, OperationType?operationType = null)
{
if (String.IsNullOrEmpty(logicDbName))
{
throw new DalException("Please specify databaseSet.");
}
if (String.IsNullOrEmpty(sql))
{
throw new DalException("Please specify sql.");
}
var result = new List <Statement>();
var tupleList = ShardingUtil.GetShardInfo(logicDbName, shardingStrategy, parameters, hints);
if (tupleList.Count < 1)
{
//非sharding的场合
Statement statement = GetStatement(logicDbName, StatementType.Sql,
operationType ?? OperationType.Default, sqlType, hints, null);
statement.StatementText = GetSql(sql, null);
statement.Parameters = parameters;
#if !NETSTANDARD
CurrentStackCustomizedLog(statement);
#endif
result.Add(statement);
}
else
{
var bulkCopy = false;
if (hints != null && hints.Contains(DALExtStatementConstant.BULK_COPY))//查看是否是批量插入的case
{
bulkCopy = Convert.ToBoolean(hints[DALExtStatementConstant.BULK_COPY]);
}
if (bulkCopy)
{
result.AddRange(BulkCopyCase(logicDbName, shardingStrategy, sql, parameters, hints, tupleList, sqlType, operationType));
}
else
{
foreach (var tuple in tupleList)
{
Statement statement = GetStatement(logicDbName, StatementType.Sql, operationType ?? OperationType.Default, sqlType, hints, tuple.Item1);
statement.StatementText = GetSql(sql, tuple.Item2);
statement.Parameters = parameters;
#if !NETSTANDARD
CurrentStackCustomizedLog(statement);
#endif
result.Add(statement);
}
}
}
return(result);
}
/// <summary>
/// 执行单返回值聚集查询指令
/// </summary>
/// <param name="sql">sql语句</param>
/// <param name="parameters">查询参数</param>
/// <param name="hints">指令参数：如timeout</param>
/// <param name="operationType">操作类型，读写分离，默认从master库读取</param>
/// <returns>object</returns>
/// <exception cref="DalException">数据访问框架异常</exception>
public Object ExecScalar(String sql, StatementParameterCollection parameters, IDictionary hints, OperationType operationType)
{
try
{
Object result = null;
if (!IsShardEnabled)
{
Statement statement = SqlBuilder.GetScalarStatement(LogicDbName, ShardingStrategy, sql, parameters, hints, operationType).Single();
AddSqlToExtendParams(statement, hints);
result = DatabaseBridge.Instance.ExecuteScalar(statement);
}
else
{
var statements = ShardingUtil.GetShardStatement(LogicDbName, ShardingStrategy, parameters, hints,
newHints => SqlBuilder.GetScalarStatement(LogicDbName, ShardingStrategy, sql, parameters, newHints, operationType), SqlStatementType.SELECT);
var temp = ShardingExecutor.ExecuteShardingScalar(statements);
if (temp.Count > 0)
{
if (temp.Count == 1)
{
result = temp[0];
}
else
{
throw new DalException("ExecScalar exception:more than one shard.");
}
}
}
return(result);
}
catch (Exception ex)
{
throw;
}
finally
{
}
}
/// <summary>
/// 执行单返回值聚集查询指令
/// </summary>
/// <param name="sql">sql语句</param>
/// <param name="parameters">查询参数</param>
/// <param name="hints">指令参数：如timeout</param>
/// <param name="operationType">操作类型，读写分离，默认从master库读取</param>
/// <returns>object</returns>
/// <exception cref="DalException">数据访问框架异常</exception>
public Object ExecScalar(String sql, StatementParameterCollection parameters, IDictionary hints, OperationType operationType)
{
Object result = null;
if (!IsShardEnabled)
{
Statement statement = SqlBuilder.GetScalarStatement(LogicDbName, ShardingStrategy, sql, parameters, hints, operationType).Single();
AddSqlToExtendParams(statement, hints);
try
{
result = DatabaseBridge.Instance.ExecuteScalar(statement);
return(result);
}
finally
{
RunTimeDetail runTimeDetail = new RunTimeDetail
{
DbName = statement.DbName,
Duration = statement.Duration,
Server = statement.HostName
};
if (hints != null)
{
hints.Add(DALExtStatementConstant.EXCUTE_TIME, new List <RunTimeDetail> {
runTimeDetail
});
}
}
}
else
{
var statements = ShardingUtil.GetShardStatement(LogicDbName, ShardingStrategy, parameters, hints,
newHints => SqlBuilder.GetScalarStatement(LogicDbName, ShardingStrategy, sql, parameters, newHints, operationType), SqlStatementType.SELECT);
try
{
var temp = ShardingExecutor.ExecuteShardingScalar(statements);
if (temp.Count == 1)
{
result = temp[0];
return(result);
}
else
{
throw new DalException("ExecScalar exception:more than one shard.");
}
}
finally
{
var runTimeList = new List <RunTimeDetail>();
foreach (var statement in statements)
{
RunTimeDetail runTimeDetail = new RunTimeDetail
{
DbName = statement.DbName,
Duration = statement.Duration,
Server = statement.HostName
};
runTimeList.Add(runTimeDetail);
}
if (hints != null)
{
hints.Add(DALExtStatementConstant.EXCUTE_TIME, runTimeList);
}
}
}
}
void innerStart()
{
while (!toStop1)
{
running = false;
idleTimes++;
try
{
// to check toStop signal, we need cycle, so wo cannot use queue.take(), instand of poll(timeout)
var result = triggerQueue.TryTake(out TriggerParam triggerParam, 3 * 1000);
if (triggerParam != null)
{
running = true;
idleTimes = 0;
triggerLogIdSet.Remove(triggerParam.logId);
// parse param
string[] handlerParams = (triggerParam.executorParams != null && triggerParam.executorParams.Trim().Length > 0)
? triggerParam.executorParams.Split(',') : null;
// handle job
ReturnT <String> executeResult = null;
try
{
// log filename: yyyy-MM-dd/9999.log
String logFileName = XxlJobFileAppender.makeLogFileName(TimeUtil.ToTime(triggerParam.logDateTim), triggerParam.logId);
XxlJobFileAppender.contextHolder.Value = (logFileName);
ShardingUtil.setShardingVo(new ShardingUtil.ShardingVO(triggerParam.broadcastIndex, triggerParam.broadcastTotal));
XxlJobLogger.log("<br>----------- xxl-job job execute start -----------<br>----------- Params:" + string.Join(",", handlerParams ?? new[] { "" }));
executeResult = handler.execute(handlerParams);
if (executeResult == null)
{
executeResult = ReturnT <string> .FAIL;
}
XxlJobLogger.log("<br>----------- xxl-job job execute end(finish) -----------<br>----------- ReturnT:" + executeResult);
}
catch (Exception e)
{
if (toStop1)
{
XxlJobLogger.log("<br>----------- JobThread toStop, stopReason:" + stopReason);
}
//StringWriter stringWriter = new StringWriter();
//e.printStackTrace(new PrintWriter(stringWriter));
String errorMsg = e.ToString();
executeResult = new ReturnT <String>(ReturnT <string> .FAIL_CODE, errorMsg);
XxlJobLogger.log("<br>----------- JobThread Exception:" + errorMsg + "<br>----------- xxl-job job execute end(error) -----------");
}
// callback handler info
if (!toStop1)
{
// commonm
TriggerCallbackThread.pushCallBack(new HandleCallbackParam(triggerParam.logId, executeResult));
}
else
{
// is killed
ReturnT <String> stopResult = new ReturnT <String>(ReturnT <string> .FAIL_CODE, stopReason + " [业务运行中，被强制终止]");
TriggerCallbackThread.pushCallBack(new HandleCallbackParam(triggerParam.logId, stopResult));
}
}
else
{
if (idleTimes > 30)
{
XxlJobExecutor.removeJobThread(jobId, "excutor idel times over limit.");
}
}
}
catch (Exception e)
{
if (toStop1)
{
XxlJobLogger.log("<br>----------- xxl-job toStop, stopReason:" + stopReason);
}
String errorMsg = e.ToString();
XxlJobLogger.log("----------- xxl-job JobThread Exception:" + errorMsg);
}
}
// callback trigger request in queue
while (triggerQueue != null && triggerQueue.Count > 0)
{
triggerQueue.TryTake(out TriggerParam triggerParam);
if (triggerParam != null)
{
// is killed
ReturnT <String> stopResult = new ReturnT <String>(ReturnT <string> .FAIL_CODE, stopReason + " [任务尚未执行，在调度队列中被终止]");
TriggerCallbackThread.pushCallBack(new HandleCallbackParam(triggerParam.logId, stopResult));
}
}
logger.Info(string.Format(">>>>>>>>>>>> xxl-job JobThread stoped, hashCode:{0}", Thread.CurrentThread));
}
