public MySqlSchemaTest()
{
const string connectionStringName = "MySqlELinq";
//DbConfiguration.InitializeDLinq<System.Data.Linq.Binary>();
if (!DbConfiguration.Items.TryGetValue(connectionStringName, out dbConfiguration))
{
dbConfiguration = DbConfiguration.Configure(connectionStringName)
.SetSqlLogger(() => new SqlLog(Console.Out))
;
}
DataTable tb = null;
using ( var conn = dbConfiguration.DbProviderFactory.CreateConnection())
{
conn.ConnectionString = dbConfiguration.ConnectionString;
conn.Open();
tb = conn.GetSchema("DATATYPES", null);
}
tb.WriteXml(Console.Out);
var items = tb.Rows.Cast<DataRow>().Select(p => p["TypeName"].ToString()).ToArray();
foreach (DataRow item in tb.Rows)
Console.WriteLine(string.Format("TypeName:{0},ProviderDbType:{1},DataType:{2}"
,item["TypeName"]
,item["ProviderDbType"]
,item["DataType"]));
}
static UCDbContext()
{
dbConfiguration = DbConfiguration
.Configure(connectionStringName)
.SetSqlLogger(() =>SqlLog.Debug)
.AddFromAssemblyOf<UCDbContext>(t=>t.HasAttribute<TableAttribute>(false))
;
}
/// <summary>
/// 根据dbConfiguration 创建DbContext对象
/// </summary>
/// <param name="dbConfiguration"></param>
public DbContext(DbConfiguration dbConfiguration)
{
Guard.NotNull(dbConfiguration, "dbConfiguration");
InnerContext = new InternalDbContext(dbConfiguration);
DbConfiguration = dbConfiguration;
Connection = InnerContext.Connection;
DbHelper = InnerContext.DbHelper;
InitializeDbSets();
}
private static void AutoMatchDialect(DbConfiguration cfg, string connectionString, string providerName, DbProviderFactory factory)
{
if (Options.ContainsKey(providerName))
{
cfg.Option = Options[providerName];
}
PopulateSqlServer2000(cfg, factory);
}
/// <summary>
/// 通过connectionStringName对象创建DbConfiguration对象（可以用于配置文件中有多个数据库连接字符串配置）
/// </summary>
/// <param name="connectionStringName"></param>
/// <returns></returns>
public static DbConfiguration Configure(string connectionStringName)
{
Guard.NotNullOrEmpty(connectionStringName, "connectionStringName");
DbConfiguration cfg;
if (items.TryGetValue(connectionStringName, out cfg))
{
return(cfg);
}
var item = System.Configuration.ConfigurationManager.ConnectionStrings[connectionStringName];
if (item == null)
{
throw new ConfigurationErrorsException(string.Format(Res.ConnectionStringNameInvalid, connectionStringName));
}
if (string.IsNullOrEmpty(item.ProviderName))
{
throw new ConfigurationErrorsException("connectionString.ProviderName");
}
var connectionString = item.ConnectionString;
if (string.IsNullOrEmpty(connectionString))
{
throw new ConfigurationErrorsException("ConnectionString");
}
var providerName = providerNames.FirstOrDefault(p => p == item.ProviderName);
if (providerName.IsNullOrEmpty())
{
throw new ConfigurationErrorsException(item.ProviderName + " Provider name not exists or invalid for" + connectionStringName);
}
DbProviderFactory factory = null;
try
{
factory = DbProviderFactories.GetFactory(providerName);
}
catch (Exception ex)
{
throw new ConfigurationErrorsException(providerName + " Provider name invalid for" + connectionStringName, ex);
}
cfg = new DbConfiguration(providerName, item.Name, connectionString, factory);
lock (items)
items[cfg.Name] = cfg;
AutoMatchDialect(cfg, connectionString, providerName, factory);
return(cfg);
}
private InternalDbContext(DbConfiguration dbConfiguration, DbConnection conn, bool hasSelfCreateConnection)
{
Driver = dbConfiguration.Driver;
Dialect = dbConfiguration.Dialect;
this.dbConfiguration = dbConfiguration;
connection = conn;
Operations = new Dictionary <MemberInfo, List <LambdaExpression> >();
this.ExpressionBuilder = dbConfiguration.Option.DbExpressionBuilder;
Log = dbConfiguration.sqlLogger();
HasSelfCreateConnection = hasSelfCreateConnection;
}
public virtual IDatabaseSchema Load(DbConfiguration cfg)
{
var databaseSchema = new DatabaseSchema();
ColumnInfo[] allColumns = null;
ConstraintInfo[] allConstraints = null;
ForeignKeyInfo[] allFks = null;
using (var ctx = cfg.CreateDbContext())
{
InitConnection(ctx.Connection);
using (var reader = ctx.DbHelper.ExecuteReader(AllColumnsSql))
allColumns = reader.ToList<ColumnInfo>().ToArray();
using (var reader = ctx.DbHelper.ExecuteReader(AllConstraintsSql))
allConstraints = reader.ToList<ConstraintInfo>().ToArray();
using (var reader = ctx.DbHelper.ExecuteReader(AllFKsSql))
allFks = reader.ToList<ForeignKeyInfo>().ToArray();
}
PopulateConstraints(allColumns, allConstraints);
Dictionary<string, TableSchema> tables = new Dictionary<string, TableSchema>();
PopulateTables(allColumns, tables);
foreach (var item in allFks)
{
TableSchema thisTable = null;
TableSchema otherTable = null;
IColumnSchema thisKey = null;
IColumnSchema otherKey = null;
var key = string.Format("{0}.{1}", item.ThisSchema, item.ThisTableName);
if (tables.TryGetValue(key, out thisTable))
thisKey = thisTable.AllColumns.FirstOrDefault(p => p.ColumnName == item.ThisKey);
key = string.Format("{0}.{1}", item.OtherSchema, item.OtherTableName);
if(tables.TryGetValue(key, out otherTable))
otherKey = otherTable.AllColumns.FirstOrDefault(p => p.ColumnName == item.OtherKey);
thisTable.AddFK(new ForeignKeySchema
{
ThisTable = thisTable
, Name = item.Name
, ThisKey = thisKey
, OtherTable = otherTable
, OtherKey = otherKey });
}
databaseSchema.Tables = tables.Values.Where(p => !p.IsView).ToArray();
databaseSchema.Views = tables.Values.Where(p => p.IsView).ToArray();
return databaseSchema;
}
public SQLiteDDLTest()
{
const string connectionStringName = "ELinq";
//DbConfiguration.InitializeDLinq<System.Data.Linq.Binary>();
if (!DbConfiguration.Items.TryGetValue(connectionStringName, out dbConfiguration))
{
dbConfiguration = DbConfiguration.ConfigureSQLite(@"Northwind.sl")
.SetSqlLogger(() => new SqlLog(Console.Out))
.AddFromAssemblyOf<ELinq.DDLTest.Models.Customers>(p => p.HasAttribute<System.Data.Linq.Mapping.TableAttribute>(false));
}
}
/// <summary>
/// 通过缺省的连接字串配置创建DbConfiguration对象（当且仅当配置文件中只有一个数据库连接字符串配置时才能使用）
/// </summary>
/// <returns></returns>
public static DbConfiguration Configure()
{
if (System.Configuration.ConfigurationManager.ConnectionStrings.Count == 0)
{
throw new ConfigurationErrorsException(Res.ConnectionStringNoConfigException);
}
if (System.Configuration.ConfigurationManager.ConnectionStrings.Count != 1)
{
throw new ConfigurationErrorsException(Res.ConnectionStringNoConfigException);
}
return(DbConfiguration.Configure(System.Configuration.ConfigurationManager.ConnectionStrings[0].Name).MakeDefault());
}
public SqlServerSchema()
{
const string connectionStringName = "Northwind";
//DbConfiguration.InitializeDLinq<System.Data.Linq.Binary>();
if (!DbConfiguration.Items.TryGetValue(connectionStringName, out dbConfiguration))
{
dbConfiguration = DbConfiguration.Configure(connectionStringName)
.SetSqlLogger(() => new SqlLog(Console.Out))
;
}
}
public DDLTest()
{
const string connectionStringName = "ELinq";
//DbConfiguration.InitializeDLinq<System.Data.Linq.Binary>();
if (!DbConfiguration.Items.TryGetValue(connectionStringName, out dbConfiguration))
{
dbConfiguration = DbConfiguration.Configure(connectionStringName)
.SetSqlLogger(() => new SqlLog(Console.Out))
.AddFromAssemblyOf<ELinq.DDLTest.ElinqToSql.Models.Customers>(t => t.HasAttribute<TableAttribute>(false));
}
}
internal static DbConfiguration Get(string dbConfigurationName)
{
Guard.NotNull(dbConfigurationName, "dbConfigurationName");
DbConfiguration cfg;
items.TryGetValue(dbConfigurationName, out cfg);
if (cfg == null)
{
//自动配置
cfg = DbConfiguration.Configure(dbConfigurationName);
}
return(cfg);
}
public SqlCEDDLTest()
{
const string connectionStringName = "SqlCELinq";
//DbConfiguration.InitializeDLinq<System.Data.Linq.Binary>();
if (!DbConfiguration.Items.TryGetValue(connectionStringName, out dbConfiguration))
{
dbConfiguration = DbConfiguration.ConfigureSqlCe35("Northwind.sdf")
//dbConfiguration = DbConfiguration.Configure(connectionStringName)
.SetSqlLogger(() => new SqlLog(Console.Out))
.AddFromAssemblyOf<ELinq.DDLTest.ElinqToSql.Models.EmployeeTerritories>(t => t.HasAttribute<TableAttribute>(false));
}
}
/// <summary>
/// 得到工作单元对象
/// </summary>
/// <param name="dbConfigurationName"></param>
/// <returns></returns>
public static IUnitOfWork Get(string dbConfigurationName)
{
Guard.NotNullOrEmpty(dbConfigurationName, "dbConfigurationName");
var key = string.Concat("__", dbConfigurationName, "__");
var ctx = NLite.Threading.Local.Get(key) as IUnitOfWork;
if (ctx == null)
{
var cfg = DbConfiguration.Get(dbConfigurationName);
ctx = cfg.CreateDbContext() as IUnitOfWork;
NLite.Threading.Local.Set(key, ctx);
}
return(ctx);
}
private static void PopulateSqlServer2000(DbConfiguration cfg, DbProviderFactory factory)
{
if (factory is System.Data.SqlClient.SqlClientFactory)
{
var connectionStringBuilder = factory.CreateConnectionStringBuilder();
connectionStringBuilder.ConnectionString = cfg.ConnectionString;
connectionStringBuilder["Database"] = "master";
using (var conn = factory.CreateConnection())
{
conn.ConnectionString = connectionStringBuilder.ConnectionString;
conn.Open();
var serverVersion = conn.ServerVersion;
var version = int.Parse(serverVersion.Substring(0, 2));
if (version < 9)
{
InitMsSql2000(cfg);
}
}
}
}
private void InitializeDbSets()
{
var type = GetType();
if (type == typeof(InternalDbContext))
{
return;
}
List <MemberInitializer> items;
if (!MemberInitializersGroup.TryGetValue(DbConfiguration.Name, out items))
{
items = new List <MemberInitializer>();
foreach (var item in type.GetFields().Where(p => typeof(IDbSet).IsAssignableFrom(p.FieldType)))
{
var initiazer = new MemberInitializer();
initiazer.EntityModel = DbConfiguration.GetMapping(ReflectionHelper.GetElementType(item.FieldType));
initiazer.Setter = item.GetSetter();
initiazer.DbSetConstrctor = typeof(DbSet <>).MakeGenericType(initiazer.EntityModel.EntityType).GetConstructors().FirstOrDefault().GetCreator();
items.Add(initiazer);
}
foreach (var item in type.GetProperties().Where(p => typeof(IDbSet).IsAssignableFrom(p.PropertyType)).Where(p => p.CanWrite))
{
var initiazer = new MemberInitializer();
initiazer.EntityModel = DbConfiguration.GetMapping(ReflectionHelper.GetElementType(item.PropertyType));
initiazer.Setter = item.GetSetter();
initiazer.DbSetConstrctor = typeof(DbSet <>).MakeGenericType(initiazer.EntityModel.EntityType).GetConstructors().FirstOrDefault().GetCreator();
items.Add(initiazer);
}
lock (MemberInitializersGroup)
MemberInitializersGroup[DbConfiguration.Name] = items;
}
foreach (var item in items)
{
item.Init(this);
}
}
/// <summary>
/// 通过DbConnection对象创建DbConfiguration对象
/// </summary>
/// <param name="conn"></param>
/// <returns></returns>
public static DbConfiguration Configure(DbConnection conn)
{
Guard.NotNull(conn, "conn");
var providerType = conn.GetType()
.Assembly
.GetTypes()
.Where(t => typeof(System.Data.Common.DbProviderFactory).IsAssignableFrom(t)
&& t.Namespace == conn.GetType().Namespace)
.FirstOrDefault()
;
if (providerType == null)
throw new NotSupportedException("not found 'DbProviderFactory'");
var factory = providerType.GetField("Instance", BindingFlags.Public | BindingFlags.Static).GetValue(null) as DbProviderFactory;
Guard.NotNull(factory, "factory");
var providerName = providerType.Namespace;
var cfg = new DbConfiguration(providerName, Guid.NewGuid().ToString(), conn.ConnectionString, factory);
if (!Options.ContainsKey(providerName))
{
var dbtype = conn.GetType().Name;
if (dbtype.StartsWith("MySql")) providerName = DbProviderNames.MySQL;
else if (dbtype.StartsWith("SqlCe")) providerName = DbProviderNames.SqlCe35;
else if (dbtype.StartsWith("Oledb")) providerName = DbProviderNames.Oledb;
else if (dbtype.StartsWith("Oracle")) providerName = DbProviderNames.Oracle;
else if (dbtype.StartsWith("SQLite")) providerName = DbProviderNames.SQLite;
else if (dbtype.StartsWith("System.Data.SqlClient.")) providerName = DbProviderNames.SqlServer;
}
if (Options.ContainsKey(providerName))
{
cfg.Option = Options[providerName];
}
PopulateSqlServer2000(conn, factory, cfg);
cfg.connection = conn;
return cfg;
}
/// <summary>
/// 配置Oracle ODP
/// </summary>
/// <param name="connectionString"></param>
/// <returns></returns>
public static DbConfiguration ConfigureOracleODP(string connectionString)
{
return(DbConfiguration.Configure(connectionString, DbProviderNames.Oracle_ODP));
}
/// <summary>
/// 配置SqlServer
/// </summary>
/// <param name="connectionString"></param>
/// <returns></returns>
public static DbConfiguration ConfigureSqlServer(string connectionString)
{
return(DbConfiguration.Configure(connectionString, DbProviderNames.SqlServer));
}
/// <summary>
/// 配置MySQL
/// </summary>
/// <param name="connectionString"></param>
/// <returns></returns>
public static DbConfiguration ConfigureMySQL(string connectionString)
{
return(DbConfiguration.Configure(connectionString, DbProviderNames.MySQL));
}
public ManagedODPConnectionWrapper(DbConfiguration dbConfiguraiton, DbConnection conn)
: base(dbConfiguraiton, conn, "Oracle.ManagedDataAccess.Client.OracleCommand")
{
}
/// <summary>
/// 根据dbConfigurationName 创建DbContext对象
/// </summary>
/// <param name="dbConfigurationName"></param>
public DbContext(string dbConfigurationName) : this(DbConfiguration.Get(dbConfigurationName))
{
}
public SQLiteConnectionWrapper(DbConfiguration dbConfiguraiton, DbConnection conn)
: base(dbConfiguraiton, conn)
{
}
/// <summary>
/// 通过connectionStringName对象创建DbConfiguration对象（可以用于配置文件中有多个数据库连接字符串配置）
/// </summary>
/// <param name="connectionStringName"></param>
/// <returns></returns>
public static DbConfiguration Configure(string connectionStringName)
{
Guard.NotNullOrEmpty(connectionStringName, "connectionStringName");
DbConfiguration cfg;
if (items.TryGetValue(connectionStringName, out cfg))
return cfg;
var item = System.Configuration.ConfigurationManager.ConnectionStrings[connectionStringName];
if (item == null)
throw new ConfigurationErrorsException(string.Format(Res.ConnectionStringNameInvalid, connectionStringName));
if (string.IsNullOrEmpty(item.ProviderName))
throw new ConfigurationErrorsException("connectionString.ProviderName");
var connectionString = item.ConnectionString;
if (string.IsNullOrEmpty(connectionString))
throw new ConfigurationErrorsException("ConnectionString");
var providerName = providerNames.FirstOrDefault(p => p == item.ProviderName);
if (providerName.IsNullOrEmpty())
throw new ConfigurationErrorsException(item.ProviderName + " Provider name not exists or invalid for" + connectionStringName);
DbProviderFactory factory = null;
try
{
factory = DbProviderFactories.GetFactory(providerName);
}
catch (Exception ex)
{
throw new ConfigurationErrorsException(providerName + " Provider name invalid for" + connectionStringName, ex);
}
cfg = new DbConfiguration(providerName, item.Name, connectionString, factory);
lock (items)
items[cfg.Name] = cfg;
AutoMatchDialect(cfg, connectionString, providerName, factory);
if (System.Configuration.ConfigurationManager.ConnectionStrings.Count == 1)
cfg.MakeDefault();
return cfg;
}
public ODPConnectionWrapper(DbConfiguration dbConfiguraiton, DbConnection conn)
: base(dbConfiguraiton, conn)
{
if (_bindByNameProperty == null)
_bindByNameProperty = conn.GetType().Module.GetType("Oracle.DataAccess.Client.OracleCommand").GetProperty("BindByName").GetSetter();
}
internal InternalDbContext(DbConfiguration dbConfiguration, DbConnection conn)
: this(dbConfiguration, conn, false)
{
}
private static void AutoMatchDialect(DbConfiguration cfg, string connectionString, string providerName, DbProviderFactory factory)
{
if (Options.ContainsKey(providerName))
{
cfg.Option = Options[providerName];
}
PopulateSqlServer2000(cfg, factory);
}
private static void InitMsSql2000(DbConfiguration cfg)
{
cfg.Option.Driver = new SqlServer2000Driver();
cfg.Option.Dialect = new MsSql2000Dialect();
cfg.Option.ScriptExecutor = () => new SqlServer2000ScriptExecutor();
cfg.Option.FuncRegistry = new NLite.Data.Dialect.Function.MsSql.MsSqlFunctionRegistry();
cfg.Option.DbExpressionBuilder = new MsSql2000ExpressionBuilder();
}
/// <summary>
/// 把当前DbConfiguration标志为缺省DbConfiguration
/// </summary>
/// <returns></returns>
public DbConfiguration MakeDefault()
{
DefaultDbConfiguration = this;
return(this);
}
public InternalDbContext(DbConfiguration dbConfiguration)
: this(dbConfiguration, dbConfiguration.CreateDbConnection(), true)
{
}
/// <summary>
/// 通过connectionString和providerName创建DbConfiguration对象
/// </summary>
/// <param name="connectionString"></param>
/// <param name="providerName"></param>
/// <returns></returns>
public static DbConfiguration Configure(string connectionString, string providerName)
{
Guard.NotNullOrEmpty(connectionString, "connectionString");
Guard.NotNullOrEmpty(providerName, "providerName");
DbProviderFactory factory = null;
try
{
factory = DbProviderFactories.GetFactory(providerName);
}
catch (Exception ex)
{
throw new ConfigurationErrorsException(providerName + " Provider name invalid", ex);
}
var cfg = new DbConfiguration(providerName, Guid.NewGuid().ToString(), connectionString, factory);
lock (items)
items[cfg.Name] = cfg;
AutoMatchDialect(cfg, connectionString, providerName, factory);
return cfg;
}
/// <summary>
/// 配置SQLite
/// </summary>
/// <param name="databaseFile"></param>
/// <param name="password"></param>
/// <param name="failIfMissing"></param>
/// <returns></returns>
public static DbConfiguration ConfigureSQLite(string databaseFile, string password, bool failIfMissing)
{
return(DbConfiguration.Configure(BuildSQLiteConnectionString(databaseFile, password, failIfMissing), DbProviderNames.SQLite));
}
/// <summary>
/// 配置SqlCe4
/// </summary>
/// <param name="databaseFile"></param>
/// <returns></returns>
public static DbConfiguration ConfigureSqlCe4(string databaseFile)
{
return(DbConfiguration.Configure(BuildSqlCeConnectionString(databaseFile), DbProviderNames.SqlCe40));
}
public SQLiteConnectionWrapper(DbConfiguration dbConfiguraiton, DbConnection conn) : base(dbConfiguraiton, conn)
{
}
/// <summary>
/// 配置SQLExpress
/// </summary>
/// <param name="databaseFile"></param>
/// <returns></returns>
public static DbConfiguration ConfigureSQLExpress(string databaseFile)
{
return(DbConfiguration.Configure(BuildSQLExpressConnectionString(databaseFile), DbProviderNames.SqlServer));
}
/// <summary>
/// 配置SQLite
/// </summary>
/// <param name="databaseFile"></param>
/// <returns></returns>
public static DbConfiguration ConfigureSQLite(string databaseFile)
{
return(DbConfiguration.Configure(BuildSQLiteConnectionString(databaseFile), DbProviderNames.SQLite));
}
/// <summary>
/// 把当前DbConfiguration标志为缺省DbConfiguration
/// </summary>
/// <returns></returns>
public DbConfiguration MakeDefault()
{
DefaultDbConfiguration = this;
return this;
}
private static void PopulateSqlServer2000(DbConnection conn, DbProviderFactory factory, DbConfiguration cfg)
{
if (factory is System.Data.SqlClient.SqlClientFactory)
{
var connectionStringBuilder = factory.CreateConnectionStringBuilder();
connectionStringBuilder.ConnectionString = cfg.ConnectionString;
connectionStringBuilder["Database"] = "master";
var state = conn.State;
if (state != ConnectionState.Open)
conn.Open();
var serverVersion = conn.ServerVersion;
if (state != ConnectionState.Open)
conn.Close();
var version = int.Parse(serverVersion.Substring(0, 2));
if (version < 9)
InitMsSql2000(cfg);
}
}
/// <summary>
/// 配置Access
/// </summary>
/// <param name="databaseFile"></param>
/// <returns></returns>
public static DbConfiguration ConfigureAccess(string databaseFile)
{
return(DbConfiguration.Configure(BuildAccessConnectionString(databaseFile), DbProviderNames.Oledb));
}
public DbConnectionWrapper(DbConfiguration dbConfiguration,DbConnection conn)
{
this.innerConnection = conn;
var connTypeName = conn.GetType().FullName;
this.dbConfiguration = dbConfiguration;
}
