/// <summary>
/// 加载指定数据库类型的DbProviderFactory
/// </summary>
/// <param name="providerType">数据库类型枚举</param>
/// <returns></returns>
private static DbProviderFactory ImportDbProviderFactory(DbProviderType providerType)
{
string providerName = providerInvariantNames[providerType];
A:
if (!DbProviderFactories.TryGetFactory(providerType.ToString(), out DbProviderFactory factory))
{
//var wsd = DbProviderFactories.GetProviderInvariantNames();
//Assembly assembly = Assembly.Load(providerName);
//Type type = assembly.GetType("System.Data.SqlClient.SqlClientFactory"); //System.Data.SqlClient.SqlClientFactory
//AddFactory(providerType, type);//type//"System.Data.SqlClient.SqlClientFactory"
AddFactory(providerType.ToString(), providerName, true);
//AddFactory<System.Data.SqlClient.SqlClientFactory>("asd");
goto A;
}
//DbProviderFactory factory;
//try
//{
// //从全局程序集中查找
// factory = DbProviderFactories.GetFactory(providerName);
//}
//catch //(ArgumentException e)
//{
// factory = null;
//}
return(factory);
}
public async Task <List <TableDto> > GetSchemaAsync(
DbProviderType dbProviderType,
string connectionString,
string dbName,
string dbSchema = null)
{
Logger.LogInformation($"---- 数据库类型:{dbProviderType.ToString()}, 开始读取. ----");
var dtoTables = new List <TableDto>();
try
{
_dbProviderManager.TryGet(dbProviderType, out var dbProvider);
if (null == dbProvider)
{
Logger.LogInformation($"----数据库类型:{dbProviderType.ToString()} 对应的Provider未找到! ----");
return(null);
}
var tables = await GetSchemaByDbProviderAsync(dbProvider, connectionString, dbName, dbSchema);
Logger.LogInformation($"---- 数据库类型:{dbProviderType.ToString()}, 结束读取. ----");
dtoTables = _objectMapper.Map <List <Table>, List <TableDto> >(tables);
return(dtoTables);
}
catch (Exception ex)
{
Logger.LogError(ex, "读取数据库Schema发生异常.");
}
return(dtoTables);
}
public DbProvider(DbProviderType dbProviderType, string parameterPrefix, DbProviderFactory factory)
{
DbProviderType = dbProviderType;
Name = dbProviderType.ToString();
ParameterPrefix = parameterPrefix;
Factory = factory;
}
public void Can_Get_Provider(DbProviderType dbProviderType)
{
var result = _dbProviderManager.TryGet(dbProviderType, out var dbProvider);
result.ShouldBeTrue();
dbProvider.ShouldNotBeNull();
dbProvider.Name.ShouldBe(dbProviderType.ToString());
dbProvider.Factory.ShouldNotBeNull();
}
/// <summary>
/// Builds a Sql Server connection
/// </summary>
/// <param name="type">The DbProviderType to use</param>
/// <param name="server">The server</param>
/// <param name="database">The database</param>
/// <param name="userid">The userid</param>
/// <param name="password">The password</param>
/// <returns></returns>
public static string BuildSqlServer( DbProviderType type, string server, string database, string userid, string password ) {
switch (type) {
case DbProviderType.ODBC:
return _databases.ConnectionTypes[ "SQL Server" ].Providers[ "ODBC" ].ConnectionString( server, database, userid, password );
case DbProviderType.OLEDB:
return _databases.ConnectionTypes[ "SQL Server" ].Providers[ "OLEDB" ].ConnectionString( server, database, userid, password );
case DbProviderType.SQLSERVER:
return _databases.ConnectionTypes[ "SQL Server" ].Providers[ "Sql Connect" ].ConnectionString( server, database, userid, password );
default:
throw new Exception( type.ToString() + " is not supported. Please use DbType.ODBC, DbType.OLEDB or DbType.SQLSERVER" );
}
}
/// <summary>
/// Returns the fully filled-in sql text for a specified IDbCommand
/// </summary>
/// <param name="cmd"></param>
/// <param name="providerType"></param>
/// <returns></returns>
public static string Parse(IDbCommand cmd, DbProviderType providerType)
{
if (providerType == DbProviderType.OLEDB)
{
return ParseOleDbCommand(cmd);
}
else if (providerType == DbProviderType.SQLSERVER)
{
return ParseSqlCommand(cmd);
}
else if (providerType == DbProviderType.ORACLE) {
return ParseOracleCommand(cmd);
}
else
throw new NotImplementedException(providerType.ToString() + " is not currently supported.");
}
public static string Convert(DbProviderType t) {
switch (t) {
case DbProviderType.UNKNOWN:
return "UNKNOWN";
case DbProviderType.ODBC:
return "ODBC";
case DbProviderType.OLEDB:
return "OLEDB";
case DbProviderType.ORACLE:
return "ORACLE";
case DbProviderType.SQLSERVER:
return "SQLSERVER";
case DbProviderType.MYSQL:
return "MYSQL";
case DbProviderType.DB2:
return "DB2";
default:
throw new Exception("DbProviderType " + t.ToString() + " not found.");
}
}
/// <summary>
/// Gets the prefix by name
/// </summary>
/// <param name="ct">Ct.</param>
/// <param name="typeName">Name of the type.</param>
/// <returns></returns>
public string GetPrefixByName(DbProviderType ct, string typeName)
{
return this.GetPrefixByName(ct.ToString(), typeName);
}
/// <summary>
/// Gets the name of the id by.
/// </summary>
/// <param name="providerType">Provider type.</param>
/// <param name="typeName">Name of the type.</param>
/// <returns></returns>
public int GetIdByName(DbProviderType providerType, string typeName)
{
return this.GetIdByName(providerType.ToString(), typeName);
}
/// <summary>
/// Gets the test default by id.
/// </summary>
/// <param name="providerType">Provider type.</param>
/// <param name="id">Id.</param>
/// <returns></returns>
public string GetTestDefaultById(DbProviderType providerType, int id)
{
return this.GetTestDefaultById(providerType.ToString(), id);
}
/// <summary>
/// Gets the name by id.
/// </summary>
/// <param name="providerType">Provider type.</param>
/// <param name="id">Id.</param>
/// <returns></returns>
public string GetNameById(DbProviderType providerType, int id)
{
return this.GetNameById(providerType.ToString(), id);
}
/// <summary>
/// Gets the object by id.
/// </summary>
/// <param name="ct">Ct.</param>
/// <param name="id">Id.</param>
/// <returns></returns>
public string GetObjectById(DbProviderType ct, int id)
{
return this.GetObjectById(ct.ToString(), id);
}
/// <summary>
/// Gets the object by name
/// </summary>
/// <param name="providerType">Provider type</param>
/// <param name="typeName">Name of the type.</param>
/// <returns></returns>
public string GetObjectByName(DbProviderType providerType, string typeName)
{
return this.GetObjectByName(providerType.ToString(), typeName);
}
/// <summary>
/// 根据连接字符串， 创建线程缓存的AdoNetHelper子类实例。
/// </summary>
/// <typeparam name="T">AdoNetHelper 的子类</typeparam>
/// <param name="userName">数据库用户名</param>
/// <param name="dbname">数据库实例名</param>
/// <param name="createIfNull">如果不存在那么创建</param>
/// <returns></returns>
public static AdoNetHelper ThreadInstance(string connectionString, DbProviderType provider, bool createIfNull)
{
string CACHEKEY = string.Format("YBB.DBUtils.AdoNetHelper.ThreadInstance::{0}:{1}", connectionString, provider.ToString());
AdoNetHelper db = null;
if (HttpContext.Current != null)
{
db = HttpContext.Current.Items[CACHEKEY] as AdoNetHelper;
if (db == null)
{
if (!createIfNull)
{
return(null);
}
db = CreateInstance(connectionString, provider);
HttpContext.Current.Items[CACHEKEY] = db;
}
}
else
{
db = CallContext.GetData(CACHEKEY) as AdoNetHelper;
if (db == null)
{
if (!createIfNull)
{
return(null);
}
db = CreateInstance(connectionString, provider);
CallContext.SetData(CACHEKEY, db);
}
}
if (db == null)
{
return(null);
}
return(db);
}
public bool TryGet(DbProviderType dbProviderType, out DbProvider dbProvider)
{
return(_dbProviders.TryGetValue(dbProviderType.ToString(), out dbProvider));
}
///// <summary>
///// 将现有数据库对象注入实现
///// </summary>
///// <param name="providerInvariantName">注册的名称</param>
///// <param name="typeInvoke">使用<see cref="TypeInvoke"/>对象实现注入</param>
//public static void AddFactory(string providerInvariantName, TypeInvoke typeInvoke)
//{
// AddFactory(providerInvariantName, typeInvoke.GetType());
//}
/// <summary>
/// 将现有数据库对象注入实现
/// </summary>
/// <param name="providerType">注册数据库类型</param>
/// <param name="providerFactoryClass">对应的数据库<see cref="Type"/></param>
public static void AddFactory(DbProviderType providerType, Type providerFactoryClass)
{
AddFactory(providerType.ToString(), providerFactoryClass);
}
public DbProviderMappingUndefinedException(DbProviderType dbProviderType)
: base("DBTC:000001", $"{dbProviderType.ToString()} mapping is not defined.")
{
}
