public static string GetTableTemplate(this IDataProviderMetaData @this, ISqlCommandGenerator sqlCommandGenerator)
{
var result = "";
string safe(string value) => sqlCommandGenerator.SafeId(value);
void addTable(IDataProviderMetaData medaData)
{
var baseType = medaData.BaseClassesInOrder.LastOrDefault();
var alias = safe($"{{0}}{medaData.TableAlias}");
result += " LEFT OUTER JOIN ".OnlyWhen(result.HasValue()) +
$"{medaData.Schema.WithSuffix(".")}{medaData.TableName} AS {alias} " +
$"ON {alias}.{safe(medaData.IdColumnName)} = {safe($"{{0}}{baseType?.TableAlias}")}.{safe(baseType?.IdColumnName)}".OnlyWhen(baseType != null);
}
foreach (var parent in @this.BaseClassesInOrder)
{
addTable(parent);
}
addTable(@this);
foreach (var drived in @this.DrivedClasses)
{
addTable(drived);
}
return(result);
}
public ParameterLookupContext(ISqlCommandGenerator sqlCommandGenerator, SqlCommandDescription description, MethodInfo methodInfo, object[] values)
{
SqlCommandGenerator = sqlCommandGenerator;
Description = description;
MethodInfo = methodInfo;
Values = values;
}
public ConditionGeneratorContext(ISqlCommandGenerator sqlCommandGenerator, SqlCommandDescription sqlCommandDescription, StringBuilder sqlBuilder, ConditionInfo conditionInfo)
{
this.sqlCommandGenerator = sqlCommandGenerator;
this.sqlCommandDescription = sqlCommandDescription;
this.sqlBuilder = sqlBuilder;
this.conditionInfo = conditionInfo;
}
public void Intercept(IInvocation invocation)
{
string methodName = invocation.Method.Name;
Type typeofIDao = typeof(INpiDao <>);
Type entityType = invocation.Method.DeclaringType.GetInterface(typeofIDao.FullName).GetGenericArguments()[0];
// todo :对其单例化
ISqlCommandGenerator g = NpiServicesCollection.GetService <ISqlServerCommandGenerator>();
SqlCommandDescription d = g.Generate(invocation.Method, invocation.Arguments);
DebugLogger.Debug(d.ToString());
DapperParameters dp = new DapperParameters();
foreach (var p in d.Parameters)
{
dp[p.Key] = p.Value.Value;
}
object dbReturnedValue = null;
object handledValue = null;
DebugLogger.Debug("准备执行 Sql");
switch (d.Type)
{
case SqlCommandTypes.Insert:
case SqlCommandTypes.Update:
case SqlCommandTypes.Delete:
{
var executor = ServicesCollection.GetService <ISqlCommandExecutor>();
dbReturnedValue = executor.Execute(d.SqlCommand, dp, dbConnectionContext);
}
break;
case SqlCommandTypes.Select:
{
var querier = ServicesCollection.GetService <ISqlCommandQuerier>();
dbReturnedValue = querier.Select(entityType, d.SqlCommand, dp, dbConnectionContext);
}
break;
default:
break;
}
DebugLogger.Debug("Sql 执行完毕，开始处理结果集");
foreach (var handler in dbReturnValueHandlers)
{
if (!handler.CanHandle(invocation.Method, entityType))
{
continue;
}
handledValue = handler.Handle(invocation.Method, entityType, dbReturnedValue);
}
invocation.ReturnValue = handledValue;
DebugLogger.Debug("结果集处理完毕");
}
// <summary>
// Registgers a data Data Access instance for a specified provider type.
// </summary>
public static void Register(
Type connectionType,
ISqlCommandGenerator sqlCommandGenerator,
IParameterFactory parameterFactory)
{
ConnectionTypes[connectionType.Name] = connectionType;
CommandGenerators[connectionType] = sqlCommandGenerator;
ParameterFactories[connectionType] = parameterFactory;
}
private static int AttachParamsAndRun <T>(IDbConnection connection, T t, ISqlCommandGenerator commandGenerator)
where T : class
{
var parameters = commandGenerator
.GetColumns()
.Select(x => x.ValueAccessor(t))
.ToArray();
return(AttachParamsAndRun(connection, commandGenerator.GetSql(), parameters));
}
public override void Intercept(InterfaceInvocationInfo info)
{
this.AssertProviderIsValid();
Type typeOfIDao = typeof(INpiDao <>);
ISqlCommandGenerator g = NpiServicesCollection.GetService <ISqlServerCommandGenerator>();
SqlCommandDescription d = g.Generate(info.Method, info.Arguments);
this.EventBus.Publish(new SqlCommandDescriptionGeneratedEvent(this, d));
if (info.Method.ReturnType == typeof(void))
{
d.Mode = SqlCommandExecuteModes.Execute;
}
switch (d.Mode)
{
case SqlCommandExecuteModes.Execute:
int i = this.Executor.Execute(this.Provider.Provide(), d);
foreach (var handler in this.ExecuteResultHandlers)
{
if (!handler.CanHandle(info.Method))
{
continue;
}
info.ReturnValue = handler.Handle(info.Method, i);
}
break;
case SqlCommandExecuteModes.Query:
{
Type returnType = info.Method.ReturnType;
Type itemType;
if (TryGetIEnumerableItemType(returnType, out itemType))
{
returnType = itemType;
}
IEnumerable <object> list = this.Executor.Select(this.Provider.Provide(), d, returnType);
foreach (var handler in this.SelectResultHandlers)
{
if (!handler.CanHandle(info.Method, returnType))
{
continue;
}
info.ReturnValue = handler.Handle(info.Method, returnType, list);
}
}
break;
default:
break;
}
}
private void FillWithObjectType(ISqlCommandGenerator generator, SqlCommandDescription description, Type valueType, Func <object> valueGetter)
{
var propertyInfos = valueType.GetProperties();
foreach (var propertyInfo in propertyInfos)
{
string parameterNameOnProperty = GetParameterName(propertyInfo);
this.Fill(generator, description, parameterNameOnProperty, propertyInfo.PropertyType, () =>
{
return(propertyInfo.GetValue(valueGetter(), null));
});
}
}
public static DataProvider Get(Type type, ICache cache, IDataAccess access, ISqlCommandGenerator sqlCommandGenerator)
{
lock (Cache)
{
if (Cache.ContainsKey(type))
{
return(Cache[type]);
}
var result = new DataProvider(type, cache, access, sqlCommandGenerator);
result.Prepare();
Cache.Add(type, result);
return(result);
}
}
private void FillWithCollectionType(ISqlCommandGenerator generator, SqlCommandDescription description, string parameterName, Func <object> valueGetter)
{
var parameter = description.Parameters.Values
.Where(x => x.Name.ToLower() == parameterName.ToLower())
.FirstOrDefault();
if (parameter == null)
{
return;
}
IEnumerable collection = (IEnumerable)valueGetter();
Type itemType = GetCollectionItemType(collection);
int i = 0;
List <string> newParameterNameList = new List <string>();
bool isCollectionEmpty = true;
foreach (object item in collection)
{
isCollectionEmpty = false;
if (!IsBaseType(itemType))
{
throw new MustBeBaseTypeException(itemType);
}
var itemSqlParameter = new SqlParameterInfo()
{
Name = $"{parameter.Name}{i++}",
Value = item
};
description.AddParameter(itemSqlParameter);
newParameterNameList.Add(generator.GenerateParameterName(itemSqlParameter.Name));
}
if (isCollectionEmpty)
{
throw new EmptyCollectionException(parameterName);
}
string newParameterNameSql = newParameterNameList.Join(",", x => x);
description.SqlCommand = description.SqlCommand.Replace(generator.GenerateParameterName(parameter.Name), $"({newParameterNameSql})");
description.Parameters.Remove(parameter.Name);
}
internal DataProvider(Type type, ICache cache, IDataAccess access, ISqlCommandGenerator sqlCommandGenerator)
{
EntityType = type;
SqlCommandGenerator = sqlCommandGenerator;
Cache = cache;
Access = access;
MetaData = DataProviderMetaDataGenerator.Generate(type);
DeleteCommand = SqlCommandGenerator.GenerateDeleteCommand(MetaData);
UpdateCommand = SqlCommandGenerator.GenerateUpdateCommand(MetaData);
InsertCommand = SqlCommandGenerator.GenerateInsertCommand(MetaData);
if (UpdateCommand.IsEmpty())
{
UpdateSelf = entity => Task.CompletedTask;
}
else
{
UpdateSelf = UpdateSelfImpl;
}
}
private void Fill(ISqlCommandGenerator generator, SqlCommandDescription description, string parameterName, Type valueType, Func <object> valueGetter)
{
if (IsBaseType(valueType))
{
FillWithBaseType(description, parameterName, valueGetter);
}
else if (IsCollectionType(valueType))
{
FillWithCollectionType(generator, description, parameterName, valueGetter);
}
else if (IsObject(valueType))
{
FillWithObjectType(generator, description, valueType, valueGetter);
}
else if (IsEnum(valueType))
{
FillWithBaseType(description, parameterName, () => Convert.ToInt32(valueGetter()));
}
else
{
throw new CanNotConvertToSqlParameterException(valueType);
}
}
public static void Register <TConnection>(ISqlCommandGenerator sqlCommandGenerator, string dataProviderType)
where TConnection : DbConnection, new()
{
Accessors[dataProviderType] = new DataAccess <TConnection>(sqlCommandGenerator);
}
public static DataProvider GetOrCreate(Type type, ICache cache, IDataAccess access, ISqlCommandGenerator sqlCommandGenerator)
{
lock (ProviderCache)
{
if (!ProviderCache.TryGetValue(type, out var result))
{
result = new DataProvider(type, cache, access, sqlCommandGenerator);
result.Prepare();
ProviderCache.Add(type, result);
}
return(result);
}
}
public RepositoryClassGenerator(ISqlCommandGenerator sqlCommandGenerator)
{
_sqlCommandGenerator = sqlCommandGenerator;
}
public static void Register(Type connectionType, ISqlCommandGenerator sqlCommandGenerator, string dataProviderType)
{
var dataAccessType = typeof(DataAccess <>).MakeGenericType(connectionType);
Accessors[dataProviderType] = (IDataAccess)Activator.CreateInstance(dataAccessType, sqlCommandGenerator, null);
}
public static DataProvider GetProvider(
this Type @this, ICache cache, IDataAccess access, ISqlCommandGenerator sqlCommandGenerator)
{
return(InternalDataProviderFactory.Get(@this, cache, access, sqlCommandGenerator));
}
public CachedSqlCommandGenerator(ISqlCommandGenerator generator)
{
_sql = generator.GetSql();
_columns = generator.GetColumns().ToArray();
}
public static DataProvider GetProvider(
this IDataProviderMetaData @this, ICache cache, IDataAccess access, ISqlCommandGenerator sqlCommandGenerator)
{
return(GetProvider(@this.Type, cache, access, sqlCommandGenerator));
}
// <summary>
// Registgers a data Data Access instance for a specified provider type.
// </summary>
public static void Register(Type connectionType, ISqlCommandGenerator sqlCommandGenerator)
{
ConnectionTypes[connectionType.Name] = connectionType;
CommandGenerators[connectionType] = sqlCommandGenerator;
}
