/// <summary>
/// 获取数据库帮助对象。
/// </summary>
/// <param name="database">数据库类型</param>
/// <param name="host">数据库主机</param>
/// <param name="instance">数据库实例</param>
/// <param name="account">账号</param>
/// <param name="password">密码</param>
/// <param name="port">端口号</param>
/// <returns>数据库帮助对象</returns>
public static DbHelper Create(
DatabaseType database,
string host,
string instance,
string account,
string password,
int? port = null)
{
var connectionString = GetConnectionString(database, host, instance, account, password, port);
var dbHelper = new DbHelper(Providers[(int)database], connectionString);
switch (database)
{
case DatabaseType.MSSQL:
dbHelper.DbMetadata = new MSSQLMetadata();
break;
case DatabaseType.Oracle:
dbHelper.DbMetadata = new OracleMetadata();
break;
}
return dbHelper;
}
public DeviceDescriptor(XDevice device, DatabaseType databaseType)
{
DatabaseType = databaseType;
DescriptorType = DescriptorType.Device;
Device = device;
Build();
}
public void AddPutBit(XStateType stateType, XBinaryBase binaryBase, DatabaseType databaseType)
{
Add(FormulaOperationType.PUTBIT,
(byte)stateType,
binaryBase.GetDatabaseNo(databaseType),
"Запись состояния " + stateType.ToDescription() + " " + XBinaryBaseToString(binaryBase));
}
public DataTypeInstanceAttribute(string propertyEditorAlias = null, string name = null, Type converterType = null, DatabaseType dbType = DatabaseType.None)
{
Name = name;
PropertyEditorAlias = propertyEditorAlias;
ConverterType = converterType;
DbType = dbType;
}
public static void CBFromDb(DatabaseType dbT, string cs, ComboBox cb, string value, string text, string req)
{
cb.DataSource = null;
cb.ValueMember = value;
cb.DisplayMember = text;
cb.DataSource = UtlDb.DataTable(dbT, cs, req);
}
public DirectionBinaryObject(XDirection direction, DatabaseType databaseType)
{
DatabaseType = databaseType;
ObjectType = ObjectType.Direction;
Direction = direction;
Build();
}
public static DataTable DataTable(DatabaseType dbT, string cs, string req, params object[] paramaters)
{
DataTable t = new DataTable();
switch (dbT)
{
case DatabaseType.OleDb:
using (OleDbConnection c = Connection(dbT, cs) as OleDbConnection)
{
using (OleDbDataAdapter a = new OleDbDataAdapter(req, c))
{
for (int i = 0; i < paramaters.Length; i += 2)
{
if (req.Contains("@" + paramaters[i] as string))
{
a.SelectCommand.Parameters.AddWithValue("@" + paramaters[i] as string, paramaters[i + 1]);
}
}
a.Fill(t);
}
}
break;
default:
break;
}
return t;
}
public ConnectionInformation(string tableName, string connKey, string[] pirmaryKeys,DatabaseType dbType)
{
this.TableName = tableName;
this.ConnectionKey = connKey;
this.PrimaryKeys = pirmaryKeys;
this.DbType = dbType;
}
public static DbTypeProvider Create(DatabaseType databaseType)
{
if (databaseType == DatabaseType.Postgres)
return new PostgresDbTypeProvider();
return null;
}
private void initDatabaseType()
{
if (this.radioButton_sqlserver2000.Checked)
{
this.DatabaseType = DatabaseType.SqlServer2000;
}
else if (this.radioButton_sqlserver2005.Checked)
{
this.DatabaseType = DatabaseType.SqlServer2005;
}
else if (this.radioButton_sqlserver2008.Checked)
{
this.DatabaseType = DatabaseType.SqlServer2008;
}
else if (this.radioButton_access.Checked)
{
this.DatabaseType = DatabaseType.Access;
}
else if (this.radioButton_mysql.Checked)
{
this.DatabaseType = DatabaseType.MySql;
}
else if (this.radioButton_oracle.Checked)
{
this.DatabaseType = DatabaseType.Oracle;
}
else if (this.radioButton_sqlite.Checked)
{
this.DatabaseType = DatabaseType.Sqlite;
}
}
public DeviceBinaryObject(XDevice device, DatabaseType databaseType)
{
DatabaseType = databaseType;
ObjectType = ObjectType.Device;
Device = device;
Build();
}
private static void CheckIfAuditTableExists(Type auditRecordType, DatabaseType databaseType)
{
var classConfig = ClassConfigContainer.FindClassConfig(auditRecordType);
var table = classConfig.TableName;
var sql = string.Empty;
if (databaseType != DatabaseType.Oracle)
{
sql = string.Format("SELECT COUNT(*) " +
"FROM INFORMATION_SCHEMA.TABLES " +
"WHERE TABLE_SCHEMA = '[Schema]' AND TABLE_NAME = '{0}' OR TABLE_NAME = '{1}' ",
table.ToLower(), table);
}
else
{
sql = string.Format("SELECT COUNT(*) FROM ALL_TABLES WHERE OWNER ='[Schema]' AND TABLE_NAME ='{0}'",
table);
}
var database = DatabaseCreator.CreateDatabase();
var result = database.ExecuteScalar(sql);
if (result.ToString() == "0")
{
throw new EasylinkException("Audit table {0} does not exist in the database.", table);
}
}
private void AddCeDatabase(DatabaseType dbType)
{
try
{
var dialog = new ConnectionDialog();
string path;
if (TryGetInitialPath(package, out path))
{
dialog.InitialPath = path;
}
dialog.DbType = dbType;
dialog.ShowDDEXInfo = package.VSSupportsSimpleDDEX4Provider() || package.VSSupportsSimpleDDEX35Provider();
dialog.CouldSupportPrivateProvider =
(dbType == DatabaseType.SQLCE40 && (SqlCeToolboxPackage.VisualStudioVersion == new Version(12, 0) || SqlCeToolboxPackage.VisualStudioVersion == new Version(14, 0)) )
|| (dbType == DatabaseType.SQLCE35 && package.VSSupportsEF6());
bool? result = dialog.ShowModal();
if (result.HasValue && result.Value == true)
{
if (!string.IsNullOrWhiteSpace(dialog.ConnectionString))
{
Helpers.DataConnectionHelper.SaveDataConnection(dialog.ConnectionString, dbType, package);
ExplorerControl control = _parentWindow.Content as ExplorerControl;
control.BuildDatabaseTree();
Helpers.DataConnectionHelper.LogUsage("DatabasesAddCeDatabase");
}
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, dbType);
}
}
public static void UpgradeDatabase(DbConnection connection, DatabaseType databaseType)
{
// Figure out the current version of the schema
int currentVersion;
using (DbCommand cmd = connection.CreateCommand())
{
cmd.CommandText = "SELECT val FROM setup WHERE `key`='schemaVersion';";
using (DbDataReader reader = cmd.ExecuteReader())
{
if (!reader.Read())
currentVersion = 1;
else
currentVersion = int.Parse(reader.GetString(reader.GetOrdinal("val")));
}
}
// Now get the set of migrations we have avaiable
List<int> migrationVersions = GetMigrationVersions(databaseType);
foreach (int migration in migrationVersions)
{
if (currentVersion < migration)
{
PerformMigration(connection, databaseType, migration);
}
}
}
public EntityAttribue(string _TableName, string _ConectionName, DatabaseType _DbType, bool _EnableCache)
{
this.TableName = _TableName;
this.ConectionName = _ConectionName;
this.DbType = _DbType;
this.EnableCache = _EnableCache;
}
public WinDatabaseConfig(DatabaseType database)
{
this.Build();
m_DatabaseType = database;
switch(m_DatabaseType)
{
case DatabaseType.Oracle:
{
this.btnOracle.GrabFocus();
break;
}
case DatabaseType.SQLServer:
{
this.btnSQLServer.GrabFocus();
break;
}
case DatabaseType.MySQL:
{
this.btnMySQL.GrabFocus();
break;
}
// case DatabaseType.PostgreSQL:
// {
// this.btnPostgreSQL.GrabFocus();
// break;
// }
case DatabaseType.SQLite:
{
this.btnSQLite.GrabFocus();
break;
}
}
}
public MapperDb(DatabaseType databaseType, DbProviderFactory dbFactory, string connectionString)
{
this.DatabaseType = databaseType;
this.DbFactory = dbFactory;
this.ConnectionString = connectionString;
this.InitializeConnection();
}
public static IDbCommand CreateCommand(string CommandText, DatabaseType dbtype,
IDbConnection cnn)
{
IDbCommand cmd;
switch (dbtype)
{
case DatabaseType.Access:
cmd = new OleDbCommand
(CommandText,
(OleDbConnection)cnn);
break;
case DatabaseType.SQLServer:
cmd = new SqlCommand
(CommandText,
(SqlConnection)cnn);
break;
default:
cmd = new SqlCommand
(CommandText,
(SqlConnection)cnn);
break;
}
return cmd;
}
public static DataTable DataTableUNION(DatabaseType dbT, string cs, params string[] fieldTableUNION)
{
string req = "";
for (int i = 0; i < fieldTableUNION.Length - 2; i += 2)
{
req += "SELECT DISTINCT " + fieldTableUNION[i] + " FROM " + fieldTableUNION[i + 1] + " UNION ";
}
req += "SELECT DISTINCT " + fieldTableUNION[fieldTableUNION.Length - 2] + " FROM " + fieldTableUNION[fieldTableUNION.Length - 1];
DataTable t = new DataTable();
switch (dbT)
{
case DatabaseType.OleDb:
using (OleDbConnection c = Connection(dbT, cs) as OleDbConnection)
{
using (OleDbDataAdapter a = new OleDbDataAdapter(req, c))
{
a.Fill(t);
}
}
break;
default:
break;
}
return t;
}
public DatabaseQueryTransformRule(string connectionString, DatabaseType dbType, string query, DicomTag[] outputTags, DicomTag[] paramTags) {
_connectionString = connectionString;
_dbType = dbType;
_query = query;
_output = new List<DicomTag>(outputTags);
_params = new List<DicomTag>(paramTags);
}
private static string GetDialectNameForType(DatabaseType type)
{
Contract.Ensures(!string.IsNullOrEmpty(Contract.Result<string>()));
switch (type)
{
case DatabaseType.MsSql2005:
return typeof(global::Migrator.Providers.SqlServer.SqlServer2005Dialect).FullName;
case DatabaseType.MsSql2008:
return typeof(global::Migrator.Providers.SqlServer.SqlServerDialect).FullName;
case DatabaseType.MsSqlCe:
return typeof(global::Migrator.Providers.SqlServer.SqlServerCeDialect).FullName;
case DatabaseType.MySql:
return typeof(global::Migrator.Providers.Mysql.MysqlDialect).FullName;
case DatabaseType.Oracle10:
case DatabaseType.OracleData10:
return typeof(global::Migrator.Providers.Oracle.OracleDialect).FullName;
case DatabaseType.PostgreSql:
return typeof(global::Migrator.Providers.PostgreSQL.PostgreSQLDialect).FullName;
case DatabaseType.SQLite:
return typeof(global::Migrator.Providers.SQLite.SQLiteDialect).FullName;
case DatabaseType.DB2:
throw new NotSupportedException("The given database type does not support migrations.");
}
throw new ArgumentOutOfRangeException("type");
}
public ZoneBinaryObject(XZone zone, DatabaseType databaseType)
{
DatabaseType = databaseType;
ObjectType = ObjectType.Zone;
Zone = zone;
Build();
}
// default constructor - use values from app.config
public DbConfig()
{
m_connectionString = ConfigurationManager.AppSettings[ "connectionString" ];
m_schema = ConfigurationManager.AppSettings[ "schema" ];
m_databaseType = ( DatabaseType )Enum.Parse(
typeof( DatabaseType ), ConfigurationManager.AppSettings[ "databaseType" ]
);
}
/// <summary>
/// Specifies that the decorated type is a code-first data type
/// </summary>
/// <param name="propertyEditorAlias">The property editor alias for the data type</param>
/// <param name="name">The instance name for the data type</param>
/// <param name="converterType">The default converter type which can convert between the code-first class and an Umbraco property of that data type</param>
/// <param name="dbType">The storage type used to store the data type value in the database</param>
/// <param name="useConverter">False to use no converter if converterType is null, true to attempt to use an automatic converter.
/// Using an automatic converter requires the data type class to implement IUmbracoDataType[`Tdb]</param>
public DataTypeAttribute(string propertyEditorAlias = null, string name = null, Type converterType = null, DatabaseType dbType = DatabaseType.None, bool useConverter = true)
{
Name = name;
PropertyEditorAlias = propertyEditorAlias;
_converterType = converterType;
_dbType = dbType;
_useConverter = useConverter;
}
public DatabaseLink(DatabaseType type, string srv, string uid, string pwd, bool isWinLogin)
{
this.Type = type;
this.ServerName = srv;
this.LoginName = uid;
this.LoginPassword = pwd;
this.IsWindowsLogin = isWinLogin;
}
/// <summary>
/// On database configuration change.
/// </summary>
protected void btnDatabaseConfig_OnClick(object sender, EventArgs e)
{
WinDatabaseConfig frmDatabaseConfig = new WinDatabaseConfig(m_Database);
frmDatabaseConfig.Run();
m_Database = frmDatabaseConfig.SelectedDatabase;
frmDatabaseConfig.Destroy();
ChangeDatabase();
}
/// <summary>构造函数</summary>
/// <param name="name">表名</param>
/// <param name="description">描述</param>
/// <param name="connName"></param>
/// <param name="dbType"></param>
/// <param name="isView"></param>
public BindTableAttribute(String name, String description, String connName, DatabaseType dbType, Boolean isView)
{
Name = name;
Description = description;
ConnName = connName;
DbType = dbType;
IsView = isView;
}
public static Type Map(DatabaseType _DbType)
{
if (!_dicSessionFactory.ContainsKey(_DbType))
{
return typeof(DbSession);
}
return _dicSessionFactory[_DbType];
}
public static IDbConnection CreateConnectionByKey(string key, DatabaseType dbType)
{
ConnectionStringSettings connectionStringSettings = ConfigurationManager.ConnectionStrings[string.Concat(key, "_", (int)dbType)];
string connectionString = key;
if (connectionStringSettings != null && !string.IsNullOrEmpty(connectionStringSettings.ConnectionString))
connectionString = connectionStringSettings.ConnectionString;
return CreateConnection(connectionString, dbType);
}
public static void Register(DatabaseType _DbType, Type _TSession)
{
if (_dicSessionFactory.ContainsKey(_DbType))
{
return;
}
_dicSessionFactory.Add(_DbType, _TSession);
}
public WardsDAC(string connectionStringKey, DatabaseType type) : base(connectionStringKey, type)
{
}
private static string strGetAllColumnsSql(this IDbConnection dbConnection, DatabaseType dbType, string tableName)
{
var strGetTableColumns = string.Empty;
switch (dbType)
{
case DatabaseType.SqlServer:
strGetTableColumns = $@"SELECT a.name AS ColName, CONVERT(bit, (CASE WHEN COLUMNPROPERTY(a.id, a.name, 'IsIdentity')
= 1 THEN 1 ELSE 0 END)) AS IsIdentity, CONVERT(bit, (CASE WHEN
(SELECT COUNT(*)
FROM sysobjects
WHERE (name IN
(SELECT name
FROM sysindexes
WHERE (id = a.id) AND (indid IN
(SELECT indid
FROM sysindexkeys
WHERE (id = a.id) AND (colid IN
(SELECT colid
FROM syscolumns
WHERE (id = a.id) AND (name = a.name))))))) AND (xtype = 'PK'))
> 0 THEN 1 ELSE 0 END)) AS IsPrimaryKey, b.name AS ColumnType, COLUMNPROPERTY(a.id, a.name, 'PRECISION')
AS ColumnLength, CONVERT(bit, (CASE WHEN a.isnullable = 1 THEN 1 ELSE 0 END)) AS IsNullable, ISNULL(e.text, '')
AS DefaultValue, ISNULL(g.value, ' ') AS Comment
FROM sys.syscolumns AS a LEFT OUTER JOIN
sys.systypes AS b ON a.xtype = b.xusertype INNER JOIN
sys.sysobjects AS d ON a.id = d.id AND d.xtype = 'U' AND d.name <> 'dtproperties' LEFT OUTER JOIN
sys.syscomments AS e ON a.cdefault = e.id LEFT OUTER JOIN
sys.extended_properties AS g ON a.id = g.major_id AND a.colid = g.minor_id LEFT OUTER JOIN
sys.extended_properties AS f ON d.id = f.class AND f.minor_id = 0
WHERE (b.name IS NOT NULL) AND (d.name = '{tableName}')
ORDER BY a.id, a.colorder";
break;
case DatabaseType.MySQL:
strGetTableColumns =
"select column_name as ColName, " +
" column_default as DefaultValue," +
" IF(extra = 'auto_increment','TRUE','FALSE') as IsIdentity," +
" IF(is_nullable = 'YES','TRUE','FALSE') as IsNullable," +
" DATA_TYPE as ColumnType," +
" CHARACTER_MAXIMUM_LENGTH as ColumnLength," +
" IF(COLUMN_KEY = 'PRI','TRUE','FALSE') as IsPrimaryKey," +
" COLUMN_COMMENT as Comment " +
$" from information_schema.columns where table_schema = '{dbConnection.Database}' and table_name = '{tableName}'";
break;
case DatabaseType.PostgreSQL:
strGetTableColumns =
"select column_name as ColName," +
"data_type as ColumnType," +
"coalesce(character_maximum_length, numeric_precision, -1) as ColumnLength," +
"CAST((case is_nullable when 'NO' then 0 else 1 end) as bool) as IsNullable," +
"column_default as DefaultValue," +
"CAST((case when position('nextval' in column_default)> 0 then 1 else 0 end) as bool) as IsIdentity, " +
"CAST((case when b.pk_name is null then 0 else 1 end) as bool) as IsPrimaryKey," +
"c.DeText as Comment" +
" from information_schema.columns" +
" left join " +
" (select pg_attr.attname as colname,pg_constraint.conname as pk_name from pg_constraint " +
" inner join pg_class on pg_constraint.conrelid = pg_class.oid" +
" inner join pg_attribute pg_attr on pg_attr.attrelid = pg_class.oid and pg_attr.attnum = pg_constraint.conkey[1]" +
$" inner join pg_type on pg_type.oid = pg_attr.atttypid where pg_class.relname = '{tableName}' and pg_constraint.contype = 'p') b on b.colname = information_schema.columns.column_name " +
" left join " +
" (select attname, description as DeText from pg_class " +
" left join pg_attribute pg_attr on pg_attr.attrelid = pg_class.oid" +
" left join pg_description pg_desc on pg_desc.objoid = pg_attr.attrelid and pg_desc.objsubid = pg_attr.attnum " +
$" where pg_attr.attnum > 0 and pg_attr.attrelid = pg_class.oid and pg_class.relname = '{tableName}') c on c.attname = information_schema.columns.column_name" +
$" where table_schema = 'public' and table_name = '{tableName}' order by ordinal_position asc";
break;
default:
throw new ArgumentNullException($"这是我的错，还不支持的{dbType.ToString()}数据库类型");
}
return(strGetTableColumns);
}
public static string GetFilePath(string connectionString, DatabaseType dbType)
{
var helper = CreateEngineHelper(dbType);
return helper.PathFromConnectionString(connectionString);
}
public DefaultMigratorDatabaseType(DatabaseType DatabaseType)
{
this.databaseType = DatabaseType;
}
public static string BuildSelectSysTableColumnSql(string databaseName, string schema, string tablePrefix, DatabaseType databaseType)
{
switch (databaseType)
{
case DatabaseType.MySql:
return(BuildSelectMySqlSysTableColumnSql(databaseName, tablePrefix));
case DatabaseType.MSSQLServer:
return(BuildSelectSqlServerSysTableColumnSql(tablePrefix));
case DatabaseType.PostgreSqlClient:
return(BuildSelectPostgreSqlSysTableColumnSql(schema, tablePrefix));
case DatabaseType.Oracle:
default:
throw new NotSupportedException(databaseType.ToString());
}
}
internal static Dictionary<string, DatabaseInfo> GetDataConnections(SqlCeToolboxPackage package,
bool includeServerConnections, bool serverConnectionsOnly)
{
// http://www.mztools.com/articles/2007/MZ2007018.aspx
Dictionary<string, DatabaseInfo> databaseList = new Dictionary<string, DatabaseInfo>();
var dataExplorerConnectionManager =
package.GetServiceHelper(typeof(IVsDataExplorerConnectionManager)) as IVsDataExplorerConnectionManager;
//Test code...
//var objIVsDataProviderManager = package.GetServiceHelper(typeof(IVsDataProviderManager)) as IVsDataProviderManager;
//var objIVsDataConnectionManager = package.GetServiceHelper(typeof(IVsDataConnectionManager)) as IVsDataConnectionManager;
//var objIVsDataSourceManager = package.GetServiceHelper(typeof(IVsDataSourceManager)) as IVsDataSourceManager;
//IVsDataProvider objIVsDataProvider;
//foreach (var objIVsDataSource in objIVsDataSourceManager.Sources)
//{
// //System.Diagnostics.Debug.WriteLine(objIVsDataSource.DisplayName);
// //System.Diagnostics.Debug.WriteLine(objIVsDataSource.Guid.ToString());
// //foreach (var objProviderGuid in objIVsDataSource.GetProviders())
// //{
// // objIVsDataProvider = objIVsDataProviderManager.GetDataProvider(objProviderGuid);
// // System.Diagnostics.Debug.WriteLine(objIVsDataProvider.DisplayName);
// // System.Diagnostics.Debug.WriteLine(objIVsDataProvider.Guid.ToString());
// //}
//}
// End test code
Guid provider35 = new Guid(Resources.SqlCompact35Provider);
Guid provider40 = new Guid(Resources.SqlCompact40Provider);
Guid providerSqLite = new Guid(Resources.SQLiteProvider);
bool isV35Installed = IsV35Installed() && DdexProviderIsInstalled(provider35);
bool isV40Installed = IsV40Installed() && DdexProviderIsInstalled(provider40);
if (dataExplorerConnectionManager != null)
{
foreach (var connection in dataExplorerConnectionManager.Connections.Values)
{
try
{
var objProviderGuid = connection.Provider;
if (!serverConnectionsOnly)
{
if ((objProviderGuid == provider35 && isV35Installed) ||
(objProviderGuid == provider40 && isV40Installed))
{
DatabaseType dbType = DatabaseType.SQLCE40;
if (objProviderGuid == provider35)
dbType = DatabaseType.SQLCE35;
var serverVersion = "4.0";
if (dbType == DatabaseType.SQLCE35)
serverVersion = "3.5";
var sConnectionString =
DataProtection.DecryptString(connection.EncryptedConnectionString);
if (!sConnectionString.Contains("Mobile Device"))
{
DatabaseInfo info = new DatabaseInfo();
info.Caption = connection.DisplayName;
info.FromServerExplorer = true;
info.DatabaseType = dbType;
info.ServerVersion = serverVersion;
info.ConnectionString = sConnectionString;
info.FileIsMissing = IsMissing(info);
if (!databaseList.ContainsKey(sConnectionString))
databaseList.Add(sConnectionString, info);
}
}
if (objProviderGuid == providerSqLite)
{
DatabaseType dbType = DatabaseType.SQLite;
var sConnectionString =
DataProtection.DecryptString(connection.EncryptedConnectionString);
DatabaseInfo info = new DatabaseInfo();
info.Caption = connection.DisplayName;
info.FromServerExplorer = true;
info.DatabaseType = dbType;
//TODO Update this when SQLite provider is updated!
info.ServerVersion = "3.15";
info.ConnectionString = sConnectionString;
info.FileIsMissing = IsMissing(info);
if (!databaseList.ContainsKey(sConnectionString))
databaseList.Add(sConnectionString, info);
}
}
if (includeServerConnections && objProviderGuid == new Guid(Resources.SqlServerDotNetProvider))
{
var sConnectionString = DataProtection.DecryptString(connection.EncryptedConnectionString);
var info = new DatabaseInfo();
info.Caption = connection.DisplayName;
info.FromServerExplorer = true;
info.DatabaseType = DatabaseType.SQLServer;
info.ServerVersion = string.Empty;
info.ConnectionString = sConnectionString;
if (!databaseList.ContainsKey(sConnectionString))
databaseList.Add(sConnectionString, info);
}
}
catch (KeyNotFoundException)
{
}
catch (NullReferenceException)
{
}
}
}
#if SSMS
try
{
var objectExplorerManager = new ObjectExplorerManager(package);
var list = objectExplorerManager.GetAllServerUserDatabases();
foreach (var item in list)
{
if (!databaseList.ContainsKey(item.Key))
databaseList.Add(item.Key, item.Value);
}
}
//TODO Make SSMS 14.x (17) work with above method!
catch (MissingMethodException)
{
}
#endif
return databaseList;
}
/// <summary>
/// 获取指定的数据库帮助类
/// </summary>
/// <param name="dbType">数据库类型</param>
/// <param name="conStr">连接字符串</param>
/// <returns></returns>
public static DbHelper GetDbHelper(DatabaseType dbType, string conStr)
{
return(_container.Resolve <DbHelper>(dbType.ToString(), conStr));
}
public MenuEntityTypeDAC(string connectionStringKey, DatabaseType type) : base(connectionStringKey, type)
{
}
/// <summary>
/// Gets the JSON Template for creating a store
/// </summary>
/// <returns></returns>
public JObject GetTemplateJson()
{
// Set up the basic template
JObject template = new JObject();
template.Add("dbname", new JValue(ID));
// Build up the options object
// Don't bother included non-required options if the user hasn't adjusted them from their defaults
JObject options = new JObject();
// Index Options
options.Add(BaseStardogServer.DatabaseOptions.IndexType, new JValue(DatabaseType.ToLower()));
if (MinDifferentialIndexLimit != BaseStardogServer.DatabaseOptions.DefaultMinDifferentialIndexLimit)
{
options.Add(BaseStardogServer.DatabaseOptions.IndexDifferentialEnableLimit, new JValue(MinDifferentialIndexLimit));
}
if (MaxDifferentialIndexLimit != BaseStardogServer.DatabaseOptions.DefaultMaxDifferentialIndexLimit)
{
options.Add(BaseStardogServer.DatabaseOptions.IndexDifferentialMergeLimit, new JValue(MaxDifferentialIndexLimit));
}
if (CanoncialiseLiterals != BaseStardogServer.DatabaseOptions.DefaultCanonicaliseLiterals)
{
options.Add(BaseStardogServer.DatabaseOptions.IndexLiteralsCanonical, new JValue(CanoncialiseLiterals));
}
if (IndexNamedGraphs != BaseStardogServer.DatabaseOptions.DefaultNamedGraphIndexing)
{
options.Add(BaseStardogServer.DatabaseOptions.IndexNamedGraphs, new JValue(IndexNamedGraphs));
}
if (PersistIndexes != BaseStardogServer.DatabaseOptions.DefaultPersistIndex)
{
options.Add(BaseStardogServer.DatabaseOptions.IndexPersistTrue, new JValue(PersistIndexes));
}
if (PersistIndexesSynchronously != BaseStardogServer.DatabaseOptions.DefaultPersistIndexSync)
{
options.Add(BaseStardogServer.DatabaseOptions.IndexPersistSync, new JValue(PersistIndexesSynchronously));
}
if (AutoUpdateStatistics != BaseStardogServer.DatabaseOptions.DefaultAutoUpdateStats)
{
options.Add(BaseStardogServer.DatabaseOptions.IndexStatisticsAutoUpdate, new JValue(AutoUpdateStatistics));
}
// ICV Options
if (IcvActiveGraphs.Count > 0)
{
options.Add(BaseStardogServer.DatabaseOptions.IcvActiveGraphs, new JValue(String.Join(",", IcvActiveGraphs.ToArray())));
}
if (IcvEnabled != BaseStardogServer.DatabaseOptions.DefaultIcvEnabled)
{
options.Add(BaseStardogServer.DatabaseOptions.IcvEnabled, new JValue(IcvEnabled));
}
if (IcvReasoningMode != BaseStardogServer.DatabaseOptions.DefaultIcvReasoningMode)
{
options.Add(BaseStardogServer.DatabaseOptions.IcvReasoningType, new JValue(IcvReasoningMode.ToString()));
}
// Reasoning
if (ConsistencyChecking != BaseStardogServer.DatabaseOptions.DefaultConsistencyChecking)
{
options.Add(BaseStardogServer.DatabaseOptions.ReasoningAutoConsistency, new JValue(ConsistencyChecking));
}
if (EnablePunning != BaseStardogServer.DatabaseOptions.DefaultPunning)
{
options.Add(BaseStardogServer.DatabaseOptions.ReasoningPunning, new JValue(EnablePunning));
}
if (SchemaGraphs.Count > 0)
{
options.Add(BaseStardogServer.DatabaseOptions.ReasoningSchemaGraphs, new JValue(String.Join(",", SchemaGraphs.ToArray())));
}
// Search
if (FullTextSearch != BaseStardogServer.DatabaseOptions.DefaultFullTextSearch)
{
options.Add(BaseStardogServer.DatabaseOptions.SearchEnabled, new JValue(FullTextSearch));
}
if (SearchReindexMode.ToLower() != BaseStardogServer.DatabaseOptions.SearchReIndexModeAsync)
{
options.Add(BaseStardogServer.DatabaseOptions.SearchReIndexMode, new JValue(SearchReindexMode.ToLower()));
}
// Transactions
if (DurableTransactions != BaseStardogServer.DatabaseOptions.DefaultDurableTransactions)
{
options.Add(BaseStardogServer.DatabaseOptions.TransactionsDurable, new JValue(DurableTransactions));
}
// Add options to the Template
template.Add("options", options);
// Add empty files list
template.Add("files", new JArray());
return(template);
}
public AluminiesDAC(string connectionStringKey, DatabaseType type) : base(connectionStringKey, type)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="conString">构造参数，可以为数据库连接字符串或者DbContext</param>
/// <param name="dbType">数据库类型</param>
public DbRepository(string conString, DatabaseType dbType)
{
ConnectionString = conString;
DbType = dbType;
}
/// <summary>
/// 得到服务器默认库
/// </summary>
/// <param name="dbType"></param>
/// <returns></returns>
public static string GetServerDefaultDatabase(DatabaseType dbType)
{
var dict = ServerDefaultDatabase[dbType];
return(dict == null ? "" : dict);
}
public void TestForeignKeyDelete(DatabaseType dbtype, ForeignKeyDeleteAction action)
{
SetUpTest(true);
string dbFileName = testHome + "/" + testName + ".db";
string fdbFileName = testHome + "/" + testName + "foreign.db";
string sdbFileName = testHome + "/" + testName + "sec.db";
Database primaryDB, fdb;
SecondaryDatabase secDB;
// Open primary database.
if (dbtype == DatabaseType.BTREE)
{
BTreeDatabaseConfig btConfig = new BTreeDatabaseConfig();
btConfig.Creation = CreatePolicy.ALWAYS;
primaryDB = BTreeDatabase.Open(dbFileName, btConfig);
fdb = BTreeDatabase.Open(fdbFileName, btConfig);
}
else if (dbtype == DatabaseType.HASH)
{
HashDatabaseConfig hConfig = new HashDatabaseConfig();
hConfig.Creation = CreatePolicy.ALWAYS;
primaryDB = HashDatabase.Open(dbFileName, hConfig);
fdb = HashDatabase.Open(fdbFileName, hConfig);
}
else if (dbtype == DatabaseType.QUEUE)
{
QueueDatabaseConfig qConfig = new QueueDatabaseConfig();
qConfig.Creation = CreatePolicy.ALWAYS;
qConfig.Length = 4;
primaryDB = QueueDatabase.Open(dbFileName, qConfig);
fdb = QueueDatabase.Open(fdbFileName, qConfig);
}
else if (dbtype == DatabaseType.RECNO)
{
RecnoDatabaseConfig rConfig = new RecnoDatabaseConfig();
rConfig.Creation = CreatePolicy.ALWAYS;
primaryDB = RecnoDatabase.Open(dbFileName, rConfig);
fdb = RecnoDatabase.Open(fdbFileName, rConfig);
}
else
{
throw new ArgumentException("Invalid DatabaseType");
}
// Open secondary database.
if (dbtype == DatabaseType.BTREE)
{
SecondaryBTreeDatabaseConfig secbtConfig =
new SecondaryBTreeDatabaseConfig(primaryDB,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secbtConfig.Creation = CreatePolicy.ALWAYS;
secbtConfig.Duplicates = DuplicatesPolicy.SORTED;
if (action == ForeignKeyDeleteAction.NULLIFY)
{
secbtConfig.SetForeignKeyConstraint(fdb, action, new ForeignKeyNullifyDelegate(Nullify));
}
else
{
secbtConfig.SetForeignKeyConstraint(fdb, action);
}
secDB = SecondaryBTreeDatabase.Open(sdbFileName, secbtConfig);
}
else if (dbtype == DatabaseType.HASH)
{
SecondaryHashDatabaseConfig sechConfig =
new SecondaryHashDatabaseConfig(primaryDB,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
sechConfig.Creation = CreatePolicy.ALWAYS;
sechConfig.Duplicates = DuplicatesPolicy.SORTED;
if (action == ForeignKeyDeleteAction.NULLIFY)
{
sechConfig.SetForeignKeyConstraint(fdb, action, new ForeignKeyNullifyDelegate(Nullify));
}
else
{
sechConfig.SetForeignKeyConstraint(fdb, action);
}
secDB = SecondaryHashDatabase.Open(sdbFileName, sechConfig);
}
else if (dbtype == DatabaseType.QUEUE)
{
SecondaryQueueDatabaseConfig secqConfig =
new SecondaryQueueDatabaseConfig(primaryDB,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secqConfig.Creation = CreatePolicy.ALWAYS;
secqConfig.Length = 4;
if (action == ForeignKeyDeleteAction.NULLIFY)
{
secqConfig.SetForeignKeyConstraint(fdb, action, new ForeignKeyNullifyDelegate(Nullify));
}
else
{
secqConfig.SetForeignKeyConstraint(fdb, action);
}
secDB = SecondaryQueueDatabase.Open(sdbFileName, secqConfig);
}
else if (dbtype == DatabaseType.RECNO)
{
SecondaryRecnoDatabaseConfig secrConfig =
new SecondaryRecnoDatabaseConfig(primaryDB,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secrConfig.Creation = CreatePolicy.ALWAYS;
if (action == ForeignKeyDeleteAction.NULLIFY)
{
secrConfig.SetForeignKeyConstraint(fdb, action, new ForeignKeyNullifyDelegate(Nullify));
}
else
{
secrConfig.SetForeignKeyConstraint(fdb, action);
}
secDB = SecondaryRecnoDatabase.Open(sdbFileName, secrConfig);
}
else
{
throw new ArgumentException("Invalid DatabaseType");
}
/* Use integer keys for Queue/Recno support. */
fdb.Put(new DatabaseEntry(BitConverter.GetBytes(100)),
new DatabaseEntry(BitConverter.GetBytes(1001)));
fdb.Put(new DatabaseEntry(BitConverter.GetBytes(200)),
new DatabaseEntry(BitConverter.GetBytes(2002)));
fdb.Put(new DatabaseEntry(BitConverter.GetBytes(300)),
new DatabaseEntry(BitConverter.GetBytes(3003)));
primaryDB.Put(new DatabaseEntry(BitConverter.GetBytes(1)),
new DatabaseEntry(BitConverter.GetBytes(100)));
primaryDB.Put(new DatabaseEntry(BitConverter.GetBytes(2)),
new DatabaseEntry(BitConverter.GetBytes(200)));
if (dbtype == DatabaseType.BTREE || dbtype == DatabaseType.HASH)
{
primaryDB.Put(new DatabaseEntry(BitConverter.GetBytes(3)),
new DatabaseEntry(BitConverter.GetBytes(100)));
}
try {
fdb.Delete(new DatabaseEntry(BitConverter.GetBytes(100)));
} catch (ForeignConflictException) {
Assert.AreEqual(action, ForeignKeyDeleteAction.ABORT);
}
if (action == ForeignKeyDeleteAction.ABORT)
{
Assert.IsTrue(secDB.Exists(new DatabaseEntry(BitConverter.GetBytes(100))));
Assert.IsTrue(primaryDB.Exists(new DatabaseEntry(BitConverter.GetBytes(1))));
Assert.IsTrue(fdb.Exists(new DatabaseEntry(BitConverter.GetBytes(100))));
}
else if (action == ForeignKeyDeleteAction.CASCADE)
{
try {
Assert.IsFalse(secDB.Exists(new DatabaseEntry(BitConverter.GetBytes(100))));
} catch (KeyEmptyException) {
Assert.IsTrue(dbtype == DatabaseType.QUEUE || dbtype == DatabaseType.RECNO);
}
try {
Assert.IsFalse(primaryDB.Exists(new DatabaseEntry(BitConverter.GetBytes(1))));
} catch (KeyEmptyException) {
Assert.IsTrue(dbtype == DatabaseType.QUEUE || dbtype == DatabaseType.RECNO);
}
try {
Assert.IsFalse(fdb.Exists(new DatabaseEntry(BitConverter.GetBytes(100))));
} catch (KeyEmptyException) {
Assert.IsTrue(dbtype == DatabaseType.QUEUE || dbtype == DatabaseType.RECNO);
}
}
else if (action == ForeignKeyDeleteAction.NULLIFY)
{
try {
Assert.IsFalse(secDB.Exists(new DatabaseEntry(BitConverter.GetBytes(100))));
} catch (KeyEmptyException) {
Assert.IsTrue(dbtype == DatabaseType.QUEUE || dbtype == DatabaseType.RECNO);
}
Assert.IsTrue(primaryDB.Exists(new DatabaseEntry(BitConverter.GetBytes(1))));
try {
Assert.IsFalse(fdb.Exists(new DatabaseEntry(BitConverter.GetBytes(100))));
} catch (KeyEmptyException) {
Assert.IsTrue(dbtype == DatabaseType.QUEUE || dbtype == DatabaseType.RECNO);
}
}
// Close secondary database.
secDB.Close();
// Close primary database.
primaryDB.Close();
// Close foreign database
fdb.Close();
}
public DbSession()
{
_connKey = DbUtils.DefaultConnectionKey;
_dbType = DbUtils.GetDbTypeByConnKey(_connKey);
_connection = DbUtils.CreateDbConnection(_connKey);
}
/// <summary>
/// 获取指定的数据库帮助类
/// </summary>
/// <param name="dbType">数据库类型字符串</param>
/// <param name="conStr">连接字符串</param>
/// <returns></returns>
public static DbHelper GetDbHelper(string dbTypeStr, string conStr)
{
DatabaseType dbType = DbProviderFactoryHelper.DbTypeStrToDbType(dbTypeStr);
return(GetDbHelper(dbType, conStr));
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="nameOrConStr">数据库连接名或连接字符串</param>
/// <param name="dbType">数据库类型</param>
/// <param name="entityNamespace">数据库实体命名空间,注意,该命名空间应该包含所有需要的数据库实体</param>
public BaseDbContext(string nameOrConStr, DatabaseType dbType, string entityNamespace)
: base(GetDbConnection(nameOrConStr, dbType), true)
{
}
public void LockDatabaseType(DatabaseType databaseType)
{
databaseTypeUI1.LockDatabaseType(databaseType);
}
/// <summary>
/// 获取函数拼接后字符串
/// </summary>
/// <param name="dbType">数据库类型</param>
/// <returns>函数拼接后字符串</returns>
public override String ToString(DatabaseType dbType)
{
return(String.Format("RTRIM({0})", this._parameter));
}
public ApplicationDbContextFactory(DatabaseType type, string connectionString)
{
_ConnectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
_Type = type;
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="pagination">分页</param>
/// <param name="queryJson">查询参数</param>
/// <returns>返回分页列表</returns>
public DataTable GetPageList(Pagination pagination, string queryJson)
{
DatabaseType dataType = DbHelper.DbType;
Operator user = ERCHTMS.Code.OperatorProvider.Provider.Current();
string role = user.RoleName;
var queryParam = queryJson.ToJObject();
if (!string.IsNullOrEmpty(pagination.p_tablename))
{
}
else
{
pagination.conditionJson += string.Format(" and (t.flowstate!='0' or t.createuserid='{0}')", user.UserId);
if (user.RoleName.Contains("省级用户") || user.RoleName.Contains("集团用户"))
{
pagination.conditionJson += string.Format(@" and i.deptcode like '{0}%' ", user.OrganizeCode);
}
else
{
pagination.conditionJson += string.Format(" and t.createuserorgcode='{0}'", user.OrganizeCode);
}
#region 查表
pagination.p_kid = "t.id";
pagination.p_fields = @"t.CreateUserId,t.DutyPersonId,t.SupervisePersonId,t.FlowState,to_char(t.SuperviseDate,'yyyy-MM-dd') as SuperviseDate,
t.WorkTask,t.DutyDeptName,t.DutyPerson,t.SupervisePerson,to_char(t.FinishDate,'yyyy-MM-dd') as FinishDate,t.Remark,t1.id as fid,t1.FinishInfo,t1.SignUrl,t2.SignUrl as SignUrlT,
(select count(1) from BIS_SuperviseConfirmation c2 where c2.flag='1' and c2.superviseid=t.id) as btgnum";
pagination.p_tablename = @"BIS_SafetyWorkSupervise t left join (select * from
( select id, superviseid,FinishInfo,SignUrl ,row_number() over(partition by superviseid order by autoid desc ) rn
from BIS_SafetyWorkFeedback) where rn=1) t1
on t.id=t1.superviseid left join (select c1.* from BIS_SuperviseConfirmation c1 where c1.flag='0') t2
on t1.id=t2.feedbackid left join base_department i on t.dutydeptcode = i.encode ";
if (pagination.sidx == null)
{
pagination.sidx = "t.createdate";
}
if (pagination.sord == null)
{
pagination.sord = "desc";
}
#endregion
}
//督办时间
if (!queryParam["supervisedate"].IsEmpty())
{
pagination.conditionJson += string.Format(" and to_char(t.supervisedate,'yyyy-MM')='{0}'", queryParam["supervisedate"].ToString());
}
//查询条件
if (!queryParam["title"].IsEmpty())
{
pagination.conditionJson += string.Format(" and t.title like '%{0}%'", queryParam["title"].ToString());
}
if (!queryParam["code"].IsEmpty())
{
string deptCode = queryParam["code"].ToString();
var status = "";
if (!queryParam["flowstate"].IsEmpty())
{
status = queryParam["flowstate"].ToString();
if (!queryParam["appflag"].IsEmpty())
{
status = "";
}
}
if (status == "-1")
{
//从首页统计图跳转，部门本级数据
pagination.conditionJson += string.Format(" and t.dutydeptcode = '{0}'", deptCode);
}
else
{
pagination.conditionJson += string.Format(" and t.dutydeptcode like '%{0}%'", deptCode);
}
}
//查看范围
if (!queryParam["showrange"].IsEmpty())
{
var showRange = queryParam["showrange"].ToString();
if (showRange == "1")//待本人处理的
{
pagination.conditionJson += string.Format(" and ((t.dutypersonid='{0}' and t.flowstate='1') or (t.supervisepersonid='{0}' and t.flowstate='2') or (t.createuserid='{0}' and t.flowstate='0')) ", user.UserId);
}
else if (showRange == "2")//本人创建的
{
pagination.conditionJson += string.Format(" and t.createuserid='{0}'", user.UserId);
}
}
//状态
if (!queryParam["flowstate"].IsEmpty())
{
var status = queryParam["flowstate"].ToString();
if (!status.IsNullOrWhiteSpace())
{
if (status == "-1")
{
pagination.conditionJson += " and t.flowstate!=0";
}
else
{
pagination.conditionJson += string.Format(" and t.flowstate='{0}'", status);
}
}
}
//任务名称
if (!queryParam["keyword"].IsEmpty())
{
var keyword = queryParam["keyword"].ToString();
if (!keyword.IsNullOrWhiteSpace())
{
pagination.conditionJson += string.Format(" and t.worktask like '%{0}%'", keyword);
}
}
//首页预警指标0表示即将到期,1表示逾期
if (!queryParam["yjtype"].IsEmpty())
{
var yjtype = queryParam["yjtype"].ToString();
if (!yjtype.IsNullOrWhiteSpace())
{
if (yjtype == "0")
{
pagination.conditionJson += " and t.flowstate='1' and (t.finishdate - 2 <= sysdate and sysdate <= t.finishdate + 1)";
}
else
{
pagination.conditionJson += string.Format(" and t.flowstate='1' and to_date('{0}','yyyy-mm-dd hh24:mi:ss')>t.finishdate+1", DateTime.Now);
}
}
}
DataTable data = this.BaseRepository().FindTableByProcPager(pagination, dataType);
return(data);
}
/// <summary>
/// 根据表名，获取表所有的列
/// </summary>
/// <param name="dbConnection">数据库连接</param>
/// <param name="dbType">数据库类型</param>
/// <param name="tableName">数据库表名</param>
/// <returns></returns>
private static List <DbTableColumn> GetColumnsByTableName(this IDbConnection dbConnection, DatabaseType dbType, string tableName)
{
if (dbConnection == null)
{
throw new ArgumentNullException(nameof(dbConnection));
}
if (dbConnection.State == ConnectionState.Closed)
{
dbConnection.Open();
}
return(dbConnection.Query <DbTableColumn>(dbConnection.strGetAllColumnsSql(dbType, tableName)).ToList());
}
/// <summary>
/// 根据数据库类型获取数据库中所有的表
/// </summary>
/// <param name="dbConnection">数据库连接</param>
/// <param name="dbType">数据库类型</param>
/// <returns>数据库中表信息的列表</returns>
private static List <DbTable> GetCurrentDatabaseAllTables(this IDbConnection dbConnection, DatabaseType dbType)
{
if (dbConnection == null)
{
throw new ArgumentNullException(nameof(dbConnection));
}
if (dbConnection.State == ConnectionState.Closed)
{
dbConnection.Open();
}
return(dbConnection.Query <DbTable>(dbConnection.strGetAllTablesSql(dbType)).ToList());
}
public async Task <string> Generate(DatabaseObject dbObject, ScriptAction scriptAction)
{
string typeName = dbObject.GetType().Name;
if (dbObject is Table)
{
dbInterpreter.Option.GetTableAllObjects = true;
}
DatabaseObjectType databaseObjectType = (DatabaseObjectType)Enum.Parse(typeof(DatabaseObjectType), typeName);
SchemaInfoFilter filter = new SchemaInfoFilter()
{
DatabaseObjectType = databaseObjectType
};
filter.GetType().GetProperty($"{typeName}Names").SetValue(filter, new string[] { dbObject.Name });
SchemaInfo schemaInfo = await dbInterpreter.GetSchemaInfoAsync(filter);
DbScriptGenerator dbScriptGenerator = DbScriptGeneratorHelper.GetDbScriptGenerator(dbInterpreter);
List <Script> scripts = dbScriptGenerator.GenerateSchemaScripts(schemaInfo).Scripts;
StringBuilder sbContent = new StringBuilder();
DatabaseType databaseType = this.dbInterpreter.DatabaseType;
foreach (Script script in scripts)
{
if (databaseType == DatabaseType.SqlServer && script is SpliterScript)
{
continue;
}
string content = script.Content;
if (scriptAction == ScriptAction.ALTER && typeName != nameof(Table))
{
string objType = typeName;
if (typeName == nameof(TableTrigger))
{
objType = "TRIGGER";
}
string createFlag = "CREATE ";
int createFlagIndex = this.GetCreateIndex(content, createFlag);
if (createFlagIndex >= 0)
{
switch (databaseType)
{
case DatabaseType.SqlServer:
content = content.Substring(0, createFlagIndex) + "ALTER " + content.Substring(createFlagIndex + createFlag.Length);
break;
case DatabaseType.MySql:
content = $"DROP {objType} IF EXISTS {this.dbInterpreter.GetQuotedString(dbObject.Name)};" + Environment.NewLine + content;
break;
case DatabaseType.Oracle:
if (!Regex.IsMatch(content, @"^(CREATE[\s]+OR[\s]+REPLACE[\s]+)", RegexOptions.IgnoreCase))
{
content = content.Substring(0, createFlagIndex) + "CREATE OR REPLACE " + content.Substring(createFlagIndex + createFlag.Length);
}
break;
}
}
}
sbContent.AppendLine(content);
}
return(sbContent.ToString());
}
public ConferenceSpeakersDAC(string connectionStringKey, DatabaseType type) : base(connectionStringKey, type)
{
}
public IDatabase Create(string ip, string port, string dbName, string username, string password, DatabaseType databaseType)
{
switch (databaseType)
{
case DatabaseType.MSSql:
return(new MSSql(ip, port, dbName, username, password));
case DatabaseType.MySql:
return(new MySql(ip, dbName, username, password));
case DatabaseType.PostgreSql:
return(new PostgreSql(ip, dbName, username, password));
default:
throw new ArgumentException($"DatabaseTypes {databaseType} not supported");
}
}
public static IGenerator CreateGenerator(IRepository repository, DatabaseType databaseType)
{
return CreateGenerator(repository, null, databaseType);
}
/// <summary>
/// 获取完整数据库信息包含表和列的信息
/// </summary>
/// <param name="dbConnection">数据库连接</param>
/// <param name="dbType">数据库类型</param>
/// <returns></returns>
public static List <DbTable> GetCurrentDatabaseTableList(this IDbConnection dbConnection, DatabaseType dbType)
{
List <DbTable> tables = dbConnection.GetCurrentDatabaseAllTables(dbType);
tables.ForEach(item =>
{
item.Columns = dbConnection.GetColumnsByTableName(dbType, item.TableName);
item.Columns.ForEach(x =>
{
var csharpType = DbColumnTypeCollection.DbColumnDataTypes.FirstOrDefault(t =>
t.DatabaseType == dbType && t.ColumnTypes.Split(',').Any(p =>
p.Trim().Equals(x.ColumnType, StringComparison.OrdinalIgnoreCase)))?.CSharpType;
if (string.IsNullOrEmpty(csharpType))
{
throw new SqlTypeException($"未从字典中找到\"{x.ColumnType}\"对应的C#数据类型，请更新DbColumnTypeCollection类型映射字典。");
}
x.CSharpType = csharpType;
});
});
return(tables);
}
public PageStatusDAC(string connectionStringKey, DatabaseType type) : base(connectionStringKey, type)
{
}
public Database(DatabaseType dbType, string connKey)
{
DatabaseType = dbType;
ConnKey = connKey;
Connection = SqlConnectionFactory.CreateSqlConnection(dbType, connKey);
}
public static IGenerator CreateGenerator(IRepository repository, string outFile, DatabaseType databaseType)
{
switch (databaseType)
{
case DatabaseType.SQLServer:
return new Generator(repository, outFile, false, Properties.Settings.Default.PreserveSqlDates, false,
Properties.Settings.Default.KeepSchemaNames);
case DatabaseType.SQLCE35:
return string.IsNullOrEmpty(outFile)
? new Generator(repository)
: new Generator(repository, outFile);
case DatabaseType.SQLCE40:
return string.IsNullOrEmpty(outFile)
? new Generator4(repository)
: new Generator4(repository, outFile);
case DatabaseType.SQLite:
return new Generator(repository, outFile, false, false, true);
default:
return null;
}
}