public async Task <DataTable> GetDataTableAsync(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.GetDataTable;
var executionContext = await InvokeAsync <DataTable>(requestContext);
return(executionContext.Result.GetData() as DataTable);
}
public override void BuildSql(AbstractRequestContext context)
{
if (!IsCondition(context))
{
return;
}
Object reqVal = EnsurePropertyValue(context);
context.SqlBuilder.Append(Prepend);
if (reqVal is KeyValuePair <String, String> orderBy)
{
context.SqlBuilder.AppendFormat("{0} {1}", orderBy.Key, orderBy.Value);
return;
}
var orderBys = (reqVal as IEnumerable <KeyValuePair <String, String> >).ToArray();
for (var i = 0; i < orderBys.Length; i++)
{
orderBy = orderBys.ElementAt(i);
context.SqlBuilder.AppendFormat("{0} {1}", orderBy.Key, orderBy.Value);
if (i < (orderBys.Length - 1))
{
context.SqlBuilder.Append(",");
}
}
}
public IList <TResult> Query <TResult>(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.Query;
var executionContext = Invoke <TResult>(requestContext);
return(executionContext.Result.GetData() as IList <TResult>);
}
public override bool IsCondition(AbstractRequestContext context)
{
EnsurePropertyValue(context);
var matchedTag = GetMatchedTag(context);
return(matchedTag != null);
}
public async Task <TResult> QuerySingleAsync <TResult>(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.QuerySingle;
var executionContext = await InvokeAsync <TResult>(requestContext);
return(((SingleResultContext <TResult>)executionContext.Result).Data);
}
/// <summary>
/// 验证属性值变更状态是否满足要求
/// </summary>
/// <param name="propertyChanged"></param>
/// <param name="context"></param>
/// <returns></returns>
public static bool IsCondition(IPropertyChanged propertyChanged, AbstractRequestContext context)
{
if (propertyChanged.PropertyChanged == PropertyChangedState.Ignore)
{
return(true);
}
var changedVersion = context.GetPropertyVersion(propertyChanged.Property);
switch (changedVersion)
{
case -1:
{
return(true);
}
case 0:
{
return(propertyChanged.PropertyChanged == PropertyChangedState.Unchanged);
}
case int version when version > 0:
{
return(propertyChanged.PropertyChanged == PropertyChangedState.Changed);
}
default:
{
return(false);
}
}
}
private void InitRequest(AbstractRequestContext requestContext)
{
if (!String.IsNullOrEmpty(requestContext.RealSql))
{
requestContext.IsStatementSql = false;
}
SqlMap sqlMap = null;
if (!String.IsNullOrEmpty(requestContext.Scope))
{
sqlMap = _smartSqlConfig.GetSqlMap(requestContext.Scope);
}
if (requestContext.IsStatementSql)
{
InitByStatement(requestContext, sqlMap);
}
else
{
InitByMap(requestContext, sqlMap);
}
if (requestContext.AutoConverter == null)
{
requestContext.AutoConverter = NoneAutoConverter.INSTANCE;
}
}
public override void BuildSql(AbstractRequestContext context)
{
if (IsCondition(context))
{
BuildChildSql(context);
}
}
public override void BuildChildSql(AbstractRequestContext context)
{
bool isFirstChild = true;
foreach (var childTag in ChildTags)
{
if (!childTag.IsCondition(context))
{
continue;
}
if (isFirstChild)
{
isFirstChild = false;
context.SqlBuilder.Append(" ");
context.SqlBuilder.Append(Prepend);
context.SqlBuilder.Append(" ");
if (!(childTag is SqlText))
{
context.IgnorePrepend = true;
}
childTag.BuildSql(context);
}
else
{
childTag.BuildSql(context);
}
}
}
private void InitByStatement(AbstractRequestContext requestContext, SqlMap sqlMap)
{
requestContext.Statement = sqlMap.GetStatement(requestContext.FullSqlId);
if (requestContext.Statement.SourceChoice.HasValue)
{
requestContext.DataSourceChoice = requestContext.Statement.SourceChoice.Value;
}
else
{
if ((StatementType.Write & requestContext.Statement.StatementType)
== StatementType.Unknown)
{
requestContext.DataSourceChoice = DataSourceChoice.Write;
}
}
if (requestContext.Statement.CommandType.HasValue)
{
requestContext.CommandType = requestContext.Statement.CommandType.Value;
}
if (String.IsNullOrEmpty(requestContext.ReadDb))
{
requestContext.ReadDb = requestContext.Statement.ReadDb;
}
requestContext.CacheId = requestContext.Statement.CacheId;
requestContext.Cache = requestContext.Statement.Cache;
requestContext.ParameterMapId = requestContext.Statement.ParameterMapId;
requestContext.ParameterMap = requestContext.Statement.ParameterMap;
requestContext.ResultMapId = requestContext.Statement.ResultMapId;
requestContext.ResultMap = requestContext.Statement.ResultMap;
requestContext.MultipleResultMapId = requestContext.Statement.MultipleResultMapId;
requestContext.MultipleResultMap = requestContext.Statement.MultipleResultMap;
}
public CacheKey(AbstractRequestContext requestContext)
{
ResultType = requestContext.ExecutionContext.Result.ResultType;
var dbParameters = requestContext.Parameters.DbParameters?.Values;
if (dbParameters != null && dbParameters.Count > 0)
{
StringBuilder keyBuilder = new StringBuilder();
keyBuilder.Append(requestContext.RealSql);
keyBuilder.Append("|?");
foreach (var dbParam in dbParameters)
{
keyBuilder.AppendFormat("{0}={1}&", dbParam.ParameterName, dbParam.Value ?? "NULL");
}
Key = keyBuilder.ToString().TrimEnd('&');
}
else
{
Key = requestContext.RealSql;
}
using (HashAlgorithm hashAlg = SHA256.Create())
{
var sqlBytes = UTF8Encoding.Default.GetBytes(Key);
var hashData = hashAlg.ComputeHash(sqlBytes);
Key = Convert.ToBase64String(hashData);
if (requestContext.IsStatementSql)
{
Key = $"{requestContext.FullSqlId}:{Key}";
}
}
}
public override bool IsCondition(AbstractRequestContext context)
{
var paramVal = EnsurePropertyValue(context);
decimal numericalVal = Convert.ToDecimal(paramVal);
return(numericalVal >= Min && numericalVal <= Max);
}
public async Task <int> ExecuteAsync(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.Execute;
var executionContext = await InvokeAsync <int>(requestContext);
return(((SingleResultContext <int>)executionContext.Result).Data);
}
public async Task <IList <TResult> > QueryAsync <TResult>(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.Query;
var executionContext = await InvokeAsync <TResult>(requestContext);
return(executionContext.Result.GetData() as IList <TResult>);
}
public DataTable GetDataTable(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.GetDataTable;
var executionContext = Invoke <DataTable>(requestContext);
return(executionContext.Result.GetData() as DataTable);
}
private void InitByStatement(AbstractRequestContext requestContext, SqlMap sqlMap)
{
requestContext.Statement = sqlMap.GetStatement(requestContext.FullSqlId);
if (requestContext.Statement.SourceChoice.HasValue)
{
requestContext.DataSourceChoice = requestContext.Statement.SourceChoice.Value;
}
else
{
requestContext.DataSourceChoice = (StatementType.Write & requestContext.Statement.StatementType)
!= StatementType.Unknown ? DataSourceChoice.Write : DataSourceChoice.Read;
}
if (requestContext.Statement.CommandType.HasValue)
{
requestContext.CommandType = requestContext.Statement.CommandType.Value;
}
requestContext.Transaction = requestContext.Transaction ?? requestContext.Statement.Transaction;
requestContext.CommandTimeout = requestContext.CommandTimeout ?? requestContext.Statement.CommandTimeout;
requestContext.ReadDb = requestContext.Statement.ReadDb;
requestContext.CacheId = requestContext.Statement.CacheId;
requestContext.Cache = requestContext.Statement.Cache;
requestContext.ParameterMapId = requestContext.Statement.ParameterMapId;
requestContext.ParameterMap = requestContext.Statement.ParameterMap;
requestContext.ResultMapId = requestContext.Statement.ResultMapId;
requestContext.ResultMap = requestContext.Statement.ResultMap;
requestContext.MultipleResultMapId = requestContext.Statement.MultipleResultMapId;
requestContext.MultipleResultMap = requestContext.Statement.MultipleResultMap;
}
public TResult QuerySingle <TResult>(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.QuerySingle;
var executionContext = Invoke <TResult>(requestContext);
return(((SingleResultContext <TResult>)executionContext.Result).Data);
}
public DataSet GetDataSet(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.GetDataSet;
var executionContext = Invoke <DataSet>(requestContext);
return(executionContext.Result.GetData() as DataSet);
}
private void InitByMap(AbstractRequestContext requestContext, SqlMap sqlMap)
{
if (!string.IsNullOrEmpty(requestContext.CacheId))
{
SetCache(requestContext, sqlMap);
}
if (!String.IsNullOrEmpty(requestContext.ParameterMapId))
{
var fullParameterMapIdId = $"{requestContext.Scope}.{requestContext.ParameterMapId}";
requestContext.ParameterMap = sqlMap.GetParameterMap(fullParameterMapIdId);
}
if (!String.IsNullOrEmpty(requestContext.ResultMapId))
{
var fullResultMapId = $"{requestContext.Scope}.{requestContext.ResultMapId}";
requestContext.ResultMap = sqlMap.GetResultMap(fullResultMapId);
}
if (!String.IsNullOrEmpty(requestContext.MultipleResultMapId))
{
var fullMultipleResultMapId = $"{requestContext.Scope}.{requestContext.MultipleResultMapId}";
requestContext.MultipleResultMap = sqlMap.GetMultipleResultMap(fullMultipleResultMapId);
}
}
public int Execute(AbstractRequestContext requestContext)
{
requestContext.ExecutionType = ExecutionType.Execute;
var executionContext = Invoke <int>(requestContext);
return(((SingleResultContext <int>)executionContext.Result).Data);
}
public void BuildSql(AbstractRequestContext context)
{
foreach (ITag tag in SqlTags)
{
tag.BuildSql(context);
}
}
private void BuildItemSql_DirectValue(string itemSqlStr, AbstractRequestContext context)
{
var reqVal = (EnsurePropertyValue(context) as IEnumerable);
int itemIndex = 0;
string dbPrefix = GetDbProviderPrefix(context);
foreach (var itemVal in reqVal)
{
if (itemIndex > 0)
{
context.SqlBuilder.AppendFormat(" {0} ", Separator);
}
var itemSql = context.ExecutionContext.SmartSqlConfig.SqlParamAnalyzer
.Replace(itemSqlStr, (paramName, nameWithPrefix) =>
{
if (String.Compare(paramName, Key,
context.ExecutionContext.SmartSqlConfig.Settings.IgnoreParameterCase) != 0)
{
return(nameWithPrefix);
}
string keyName = $"{Key}{FOR_KEY_SUFFIX}_{itemIndex}";
context.Parameters.TryAdd(keyName, itemVal);
return($"{dbPrefix}{keyName}");
});
context.SqlBuilder.AppendFormat("{0}", itemSql);
itemIndex++;
}
}
public override void BuildChildSql(AbstractRequestContext context)
{
context.SqlBuilder.Append(Open);
var reqVal = (EnsurePropertyValue(context) as IEnumerable).GetEnumerator();
reqVal.MoveNext();
bool isDirectValue = IsDirectValue(reqVal.Current);
if (string.IsNullOrEmpty(Key))
{
throw new SmartSqlException("[For] tag [Key] is required!");
}
if (ChildTags.Count == 0)
{
throw new SmartSqlException("[For] tag must have childTag!");
}
if (!(ChildTags[0] is SqlText childText))
{
throw new SmartSqlException("[For] ChildTag only support SqlText!");
}
var itemSqlStr = childText.BodyText;
if (isDirectValue)
{
BuildItemSql_DirectValue(itemSqlStr, context);
}
else
{
BuildItemSql_NotDirectValue(itemSqlStr, context);
}
context.SqlBuilder.Append(Close);
}
private AbstractDataSource GetDataSource(AbstractRequestContext context)
{
var sourceChoice = context.DataSourceChoice;
var database = context.ExecutionContext.SmartSqlConfig.Database;
AbstractDataSource choiceDataSource = database.Write;
var readDataSources = database.Reads;
if (sourceChoice != DataSourceChoice.Read || readDataSources == null || readDataSources.Count <= 0)
{
return(choiceDataSource);
}
if (!string.IsNullOrEmpty(context.ReadDb))
{
if (!readDataSources.TryGetValue(context.ReadDb, out var readDataSource))
{
throw new SmartSqlException($"Can not find ReadDb:{context.ReadDb} .");
}
choiceDataSource = readDataSource;
}
else
{
var seekList = readDataSources.Values.Select(readDataSource => new WeightFilter <AbstractDataSource> .WeightSource
{
Source = readDataSource,
Weight = readDataSource.Weight
});
choiceDataSource = _weightFilter.Elect(seekList).Source;
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"DataSourceFilter GetDataSource Choice: {choiceDataSource.Name} .");
}
return(choiceDataSource);
}
public override void BuildSql(AbstractRequestContext context)
{
if (IsCondition(context))
{
context.SqlBuilder.Append(Prepend);
Ref.BuildSql(context);
}
}
public override void BuildSql(AbstractRequestContext context)
{
if (IsCondition(context))
{
Object reqVal = EnsurePropertyValue(context);
context.SqlBuilder.Append($"{Prepend}{reqVal}");
}
}
public AbstractDataSource Elect(AbstractRequestContext context)
{
if (context.ExecutionContext.SmartSqlConfig.SessionStore.LocalSession?.DataSource != null)
{
return(context.ExecutionContext.SmartSqlConfig.SessionStore.LocalSession.DataSource);
}
return(GetDataSource(context));
}
public async Task <ExecutionContext> InvokeAsync <TResult>(AbstractRequestContext requestContext)
{
Stopwatch stopwatch = null;
Guid operationId = Guid.Empty;
var executionContext = new ExecutionContext
{
Request = requestContext,
SmartSqlConfig = SmartSqlConfig,
DbSession = this,
};
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
stopwatch = Stopwatch.StartNew();
}
operationId = _diagnosticListener.WriteDbSessionInvokeBefore(executionContext);
#region Impl
switch (executionContext.Type)
{
case ExecutionType.Execute:
case ExecutionType.ExecuteScalar:
case ExecutionType.QuerySingle:
case ExecutionType.GetDataSet:
case ExecutionType.GetDataTable:
{
executionContext.Result = new SingleResultContext <TResult>();
break;
}
case ExecutionType.Query:
{
executionContext.Result = new ListResultContext <TResult>();
break;
}
}
requestContext.ExecutionContext = executionContext;
await Pipeline.InvokeAsync <TResult>(executionContext);
#endregion
_diagnosticListener.WriteDbSessionInvokeAfter(operationId, executionContext);
return(executionContext);
}
catch (Exception ex)
{
_diagnosticListener.WriteDbSessionInvokeError(operationId, executionContext, ex);
throw ex;
}
finally
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug(
$"Statement.Id:{(requestContext.IsStatementSql ? requestContext.FullSqlId : requestContext.RealSql)} Invoke Taken:{stopwatch?.ElapsedMilliseconds}.");
}
}
}
public void BuildSql(AbstractRequestContext context)
{
var nextId = IdGen.NextId();
if (!context.Parameters.TryAdd(Id, nextId))
{
context.Parameters.TryGetValue(Id, out Data.SqlParameter sqlParameter);
sqlParameter.Value = nextId;
}
}
private void BuildSql(AbstractRequestContext requestContext)
{
if (!requestContext.IsStatementSql)
{
return;
}
requestContext.Statement.BuildSql(requestContext);
requestContext.RealSql = requestContext.SqlBuilder.ToString().Trim();
}
