///--------------------------------------------------------------------------------
/// <summary>This loads information from a MySQL database.</summary>
///
/// <param name="sqlConnection">The input sql connection</param>
///--------------------------------------------------------------------------------
public void LoadMySQLDatabase(MySqlConnection sqlConnection)
{
try
{
// load the basic database information
SqlDatabaseName = sqlConnection.Database;
//Owner = sqlDatabase.Owner;
//PrimaryFilePath = sqlDatabase.PrimaryFilePath;
//DefaultSchema = sqlDatabase.DefaultSchema;
//DefaultFileGroup = sqlDatabase.DefaultFileGroup;
//CreateDate = sqlDatabase.CreateDate;
// load variables
NameObjectCollection variables = new NameObjectCollection();
MySqlCommand command = sqlConnection.CreateCommand();
command.CommandText = "SHOW VARIABLES;";
MySqlDataReader Reader;
Reader = command.ExecuteReader();
while (Reader.Read())
{
variables[Reader.GetValue(0).ToString()] = Reader.GetValue(1).ToString();
}
Reader.Close();
// add variables to database properties
foreach (string variable in variables.AllKeys)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
SqlProperty property = new SqlProperty();
property.SqlPropertyID = Guid.NewGuid();
property.SqlDatabase = this;
property.LoadMySQLProperty(variable, null, variables[variable].ToString());
SqlPropertyList.Add(property);
}
// load tables of schema info
DataTable tables = null;
DataTable columns = null;
DataTable indexes = null;
DataTable indexColumns = null;
DataTable foreignKeys = null;
DataTable foreignKeyColumns = null;
try
{
tables = sqlConnection.GetSchema("Tables");
}
catch
{
Solution.ShowIssue(String.Format(DisplayValues.Exception_MySQLSchemaLoad, "Tables", SqlDatabaseName), null, Solution.IsSampleMode);
}
try
{
columns = sqlConnection.GetSchema("Columns");
}
catch
{
Solution.ShowIssue(String.Format(DisplayValues.Exception_MySQLSchemaLoad, "Columns", SqlDatabaseName), null, Solution.IsSampleMode);
}
try
{
indexes = sqlConnection.GetSchema("Indexes");
}
catch
{
Solution.ShowIssue(String.Format(DisplayValues.Exception_MySQLSchemaLoad, "Indexes", SqlDatabaseName), null, Solution.IsSampleMode);
}
try
{
indexColumns = sqlConnection.GetSchema("IndexColumns");
}
catch
{
Solution.ShowIssue(String.Format(DisplayValues.Exception_MySQLSchemaLoad, "IndexColumns", SqlDatabaseName), null, Solution.IsSampleMode);
}
try
{
foreignKeys = sqlConnection.GetSchema("Foreign Keys");
}
catch
{
Solution.ShowIssue(String.Format(DisplayValues.Exception_MySQLSchemaLoad, "Foreign Keys", SqlDatabaseName), null, Solution.IsSampleMode);
}
try
{
foreignKeyColumns = sqlConnection.GetSchema("Foreign Key Columns");
}
catch
{
Solution.ShowIssue(String.Format(DisplayValues.Exception_MySQLSchemaLoad, "Foreign Key Columns", SqlDatabaseName), null, Solution.IsSampleMode);
}
// load information for each table
if (tables != null)
{
foreach (DataRow row in tables.Rows)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
SqlTable table = new SqlTable();
table.SqlTableID = Guid.NewGuid();
table.SqlDatabase = this;
table.LoadMySQLTable(sqlConnection, variables, row, columns, indexes, indexColumns, foreignKeys, foreignKeyColumns);
SqlTableList.Add(table);
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (Exception ex)
{
bool reThrow = BusinessConfiguration.HandleException(ex);
if (reThrow)
{
throw;
}
}
}
public ApplicationDbContext(BusinessConfiguration businessConfiguration) : base(businessConfiguration)
{
}
public ApplicationDbContext(DbContextOptions options, BusinessConfiguration businessConfiguration) : base(options, businessConfiguration)
{
}
///--------------------------------------------------------------------------------
/// <summary>This loads information from a MySQL foreign key.</summary>
///
/// <param name="sqlConnection">The input sql connection</param>
/// <param name="variables">Database level variables</param>
/// <param name="key">The key row data</param>
/// <param name="keyColumns">The key columns table data</param>
///--------------------------------------------------------------------------------
public void LoadMySQLForeignKey(MySqlConnection sqlConnection, NameObjectCollection variables, DataRow key, DataTable keyColumns)
{
try
{
// load foreign key information
foreach (DataColumn column in key.Table.Columns)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
// load important properties into foreign key, the rest as additional sql properties
switch (column.ColumnName)
{
case "constraint_name":
SqlForeignKeyName = key[column.ColumnName].GetString();
break;
case "referenced_table_name":
ReferencedTable = key[column.ColumnName].GetString();
break;
case "referenced_table_schema":
ReferencedTableSchema = key[column.ColumnName].GetString();
break;
default:
SqlProperty property = new SqlProperty();
property.SqlPropertyID = Guid.NewGuid();
property.SqlForeignKey = this;
property.LoadMySQLProperty(column.ColumnName, null, key[column.ColumnName].GetString());
SqlPropertyList.Add(property);
break;
}
}
// load information for each column
if (keyColumns != null)
{
foreach (DataRow row in keyColumns.Rows)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
if (row["TABLE_NAME"].GetString() == SqlTable.SqlTableName && row["CONSTRAINT_NAME"].GetString() == SqlForeignKeyName)
{
SqlForeignKeyColumn column = new SqlForeignKeyColumn();
column.SqlForeignKeyColumnID = Guid.NewGuid();
column.SqlForeignKey = this;
column.LoadMySQLColumn(sqlConnection, variables, row);
SqlForeignKeyColumnList.Add(column);
}
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (Exception ex)
{
bool reThrow = BusinessConfiguration.HandleException(ex);
if (reThrow)
{
throw;
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This loads information from a SQL foreign key.</summary>
///
/// <param name="sqlForeignKey">The input sql foreign key.</param>
///--------------------------------------------------------------------------------
public void LoadForeignKey(ForeignKey sqlForeignKey)
{
try
{
// load the basic foreign key information
SqlForeignKeyName = sqlForeignKey.Name;
DbID = sqlForeignKey.ID;
ReferencedKey = sqlForeignKey.ReferencedKey;
ReferencedTable = sqlForeignKey.ReferencedTable;
ReferencedTableSchema = sqlForeignKey.ReferencedTableSchema;
IsChecked = sqlForeignKey.IsChecked;
IsSystemNamed = sqlForeignKey.IsSystemNamed;
CreateDate = sqlForeignKey.CreateDate;
DateLastModified = sqlForeignKey.DateLastModified;
Urn = sqlForeignKey.Urn;
State = sqlForeignKey.State.ToString();
// load information for each property
foreach (Microsoft.SqlServer.Management.Smo.Property loopProperty in sqlForeignKey.Properties)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
if (loopProperty.Expensive == false && loopProperty.IsNull == false && !String.IsNullOrEmpty(loopProperty.Value.ToString()))
{
if (loopProperty.Name == "ID" || loopProperty.Name == "IsEnabled")
{
SqlProperty property = new SqlProperty();
property.SqlPropertyID = Guid.NewGuid();
property.SqlForeignKey = this;
property.LoadProperty(loopProperty);
SqlPropertyList.Add(property);
}
}
}
// load information for each extended property
//foreach (ExtendedProperty loopProperty in sqlForeignKey.ExtendedProperties)
//{
// SqlExtendedProperty property = new SqlExtendedProperty();
// property.SqlExtendedPropertyID = Guid.NewGuid();
// property.SqlForeignKey = this;
// property.LoadExtendedProperty(loopProperty);
// SqlExtendedPropertyList.Add(property);
//}
// load information for each column
foreach (ForeignKeyColumn loopColumn in sqlForeignKey.Columns)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
SqlForeignKeyColumn column = new SqlForeignKeyColumn();
column.SqlForeignKeyColumnID = Guid.NewGuid();
column.SqlForeignKey = this;
column.LoadColumn(loopColumn);
SqlForeignKeyColumnList.Add(column);
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (Exception ex)
{
bool reThrow = BusinessConfiguration.HandleException(ex);
if (reThrow)
{
throw;
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This loads information from a SQL column.</summary>
///
/// <param name="sqlColumn">The input sql column.</param>
///--------------------------------------------------------------------------------
public void LoadColumn(Column sqlColumn)
{
try
{
// load the basic column information
SqlColumnName = sqlColumn.Name;
DbID = sqlColumn.ID;
DataType = sqlColumn.DataType.ToString();
MaximumLength = sqlColumn.DataType.MaximumLength;
NumericPrecision = sqlColumn.DataType.NumericPrecision;
NumericScale = sqlColumn.DataType.NumericScale;
Default = sqlColumn.Default;
DefaultSchema = sqlColumn.DefaultSchema;
IsFullTextIndexed = sqlColumn.IsFullTextIndexed;
IsForeignKey = sqlColumn.IsForeignKey;
InPrimaryKey = sqlColumn.InPrimaryKey;
Nullable = sqlColumn.Nullable;
Identity = sqlColumn.Identity;
IdentitySeed = sqlColumn.IdentitySeed;
IdentityIncrement = sqlColumn.IdentityIncrement;
Urn = sqlColumn.Urn;
State = sqlColumn.State.ToString();
// load information for each property
foreach (Microsoft.SqlServer.Management.Smo.Property loopProperty in sqlColumn.Properties)
{
if (loopProperty.Expensive == false && loopProperty.IsNull == false && !String.IsNullOrEmpty(loopProperty.Value.ToString()))
{
if (loopProperty.Name == "ID" || loopProperty.Name == "Length")
{
SqlProperty property = new SqlProperty();
property.SqlPropertyID = Guid.NewGuid();
property.SqlColumn = this;
property.LoadProperty(loopProperty);
SqlPropertyList.Add(property);
}
}
}
// load information for each extended property
//foreach (ExtendedProperty loopProperty in sqlColumn.ExtendedProperties)
//{
// SqlExtendedProperty property = new SqlExtendedProperty();
// property.SqlExtendedPropertyID = Guid.NewGuid();
// property.SqlColumn = this;
// property.LoadExtendedProperty(loopProperty);
// SqlExtendedPropertyList.Add(property);
//}
}
catch (ApplicationAbortException)
{
throw;
}
catch (Exception ex)
{
bool reThrow = BusinessConfiguration.HandleException(ex);
if (reThrow)
{
throw;
}
}
}
public SendEmailCommand(ILogger logger, BaseDbContext dbContext, BusinessConfiguration businessConfiguration) : base(logger, dbContext)
{
_businessConfiguration = businessConfiguration;
}
private void Initialize()
{
this.calculadoraBusiness = BusinessConfiguration.GetCalculadoraBusiness();
}
///--------------------------------------------------------------------------------
/// <summary>This loads information from a MySQL column.</summary>
///
/// <param name="sqlConnection">The input sql connection</param>
/// <param name="variables">Database level variables</param>
/// <param name="column">The column row data</param>
///--------------------------------------------------------------------------------
public void LoadMySQLColumn(MySqlConnection sqlConnection, NameObjectCollection variables, DataRow column)
{
try
{
// doesn't seem to be a column property for these...
IdentitySeed = variables["auto_increment_offset"].GetInt();
IdentityIncrement = variables["auto_increment_increment"].GetInt();
//IsForeignKey = sqlColumn.IsForeignKey;
// load column information
foreach (DataColumn item in column.Table.Columns)
{
// load important properties into column, the rest as additional sql properties
switch (item.ColumnName)
{
case "COLUMN_NAME":
SqlColumnName = column[item.ColumnName].GetString();
break;
case "DATA_TYPE":
DataType = column[item.ColumnName].GetString();
break;
case "CHARACTER_MAXIMUM_LENGTH":
MaximumLength = column[item.ColumnName].GetInt();
break;
case "NUMERIC_PRECISION":
NumericPrecision = column[item.ColumnName].GetInt();
break;
case "NUMERIC_SCALE":
NumericScale = column[item.ColumnName].GetInt();
break;
case "COLUMN_DEFAULT":
Default = column[item.ColumnName].GetString();
break;
case "COLUMN_KEY":
InPrimaryKey = column[item.ColumnName].GetString() == "PRI";
break;
case "IS_NULLABLE":
Nullable = column[item.ColumnName].GetBool();
break;
case "ORDINAL_POSITION":
Order = column[item.ColumnName].GetInt();
break;
case "EXTRA":
Identity = column[item.ColumnName].GetString().Contains("auto_increment");
break;
default:
SqlProperty property = new SqlProperty();
property.SqlPropertyID = Guid.NewGuid();
property.SqlColumn = this;
property.LoadMySQLProperty(item.ColumnName, null, column[item.ColumnName].GetString());
SqlPropertyList.Add(property);
break;
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (Exception ex)
{
bool reThrow = BusinessConfiguration.HandleException(ex);
if (reThrow)
{
throw;
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This loads information from a MySQL index.</summary>
///
/// <param name="sqlConnection">The input sql connection</param>
/// <param name="variables">Database level variables</param>
/// <param name="index">The table row data</param>
/// <param name="indexColumns">The index columns table data</param>
///--------------------------------------------------------------------------------
public void LoadMySQLIndex(MySqlConnection sqlConnection, NameObjectCollection variables, DataRow index, DataTable indexColumns)
{
try
{
// load index information
foreach (DataColumn column in index.Table.Columns)
{
// load important properties into index, the rest as additional sql properties
switch (column.ColumnName)
{
case "INDEX_NAME":
SqlIndexName = index[column.ColumnName].GetString();
break;
case "PRIMARY":
IsClustered = index[column.ColumnName].GetBool(); // may not be a good setting
break;
case "UNIQUE":
IsUnique = index[column.ColumnName].GetBool();
break;
default:
SqlProperty property = new SqlProperty();
property.SqlPropertyID = Guid.NewGuid();
property.SqlIndex = this;
property.LoadMySQLProperty(column.ColumnName, null, index[column.ColumnName].GetString());
SqlPropertyList.Add(property);
break;
}
}
// load information for each column
if (indexColumns != null)
{
foreach (DataRow row in indexColumns.Rows)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
if (row["TABLE_NAME"].GetString() == SqlTable.SqlTableName && row["INDEX_NAME"].GetString() == SqlIndexName)
{
SqlIndexedColumn column = new SqlIndexedColumn();
column.SqlIndexedColumnID = Guid.NewGuid();
column.SqlIndex = this;
column.LoadMySQLColumn(sqlConnection, variables, row);
SqlIndexedColumnList.Add(column);
}
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (Exception ex)
{
bool reThrow = BusinessConfiguration.HandleException(ex);
if (reThrow)
{
throw;
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This loads information from a SQL index.</summary>
///
/// <param name="sqlIndex">The input sql index.</param>
///--------------------------------------------------------------------------------
public void LoadIndex(Index sqlIndex)
{
try
{
// load the basic index information
SqlIndexName = sqlIndex.Name;
DbID = sqlIndex.ID;
IsClustered = sqlIndex.IsClustered;
IsUnique = sqlIndex.IsUnique;
IsXmlIndex = sqlIndex.IsXmlIndex;
IsFullTextKey = sqlIndex.IsFullTextKey;
FileGroup = sqlIndex.FileGroup;
Urn = sqlIndex.Urn;
State = sqlIndex.State.ToString();
// load information for each property
foreach (Microsoft.SqlServer.Management.Smo.Property loopProperty in sqlIndex.Properties)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
if (loopProperty.Expensive == false && loopProperty.IsNull == false && !String.IsNullOrEmpty(loopProperty.Value.ToString()))
{
if (loopProperty.Name == "ID" || loopProperty.Name == "IgnoreDuplicateKeys" || loopProperty.Name == "IndexKeyType")
{
SqlProperty property = new SqlProperty();
property.SqlPropertyID = Guid.NewGuid();
property.SqlIndex = this;
property.LoadProperty(loopProperty);
SqlPropertyList.Add(property);
}
}
}
// load information for each extended property
//foreach (ExtendedProperty loopProperty in sqlIndex.ExtendedProperties)
//{
// SqlExtendedProperty property = new SqlExtendedProperty();
// property.SqlExtendedPropertyID = Guid.NewGuid();
// property.SqlIndex = this;
// property.LoadExtendedProperty(loopProperty);
// SqlExtendedPropertyList.Add(property);
//}
// load information for each column
foreach (IndexedColumn loopColumn in sqlIndex.IndexedColumns)
{
if (DebugHelper.DebugAction == DebugAction.Stop)
{
return;
}
SqlIndexedColumn column = new SqlIndexedColumn();
column.SqlIndexedColumnID = Guid.NewGuid();
column.SqlIndex = this;
column.LoadColumn(loopColumn);
SqlIndexedColumnList.Add(column);
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (Exception ex)
{
bool reThrow = BusinessConfiguration.HandleException(ex);
if (reThrow)
{
throw;
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This method loads a specification source with information from a
/// SQL database.</summary>
///--------------------------------------------------------------------------------
public void LoadSpecificationSource()
{
try
{
switch (DatabaseTypeCode)
{
case (int)BLL.Config.DatabaseTypeCode.SqlServer:
Database sqlDatabase = null;
Server sqlServer;
if (SourceDbServerName.StartsWith("(localdb)", StringComparison.OrdinalIgnoreCase))
{
var conn = new ServerConnection(new SqlConnection(String.Format("server={0};integrated security=true", SourceDbServerName)));
sqlServer = new Server(conn);
sqlServer.SetDefaultInitFields(true);
}
else
{
sqlServer = new Server(SourceDbServerName);
sqlServer.SetDefaultInitFields(true);
if (!String.IsNullOrEmpty(PasswordClearText) && !String.IsNullOrEmpty(UserName))
{
// sql server authentication
sqlServer.ConnectionContext.LoginSecure = false;
sqlServer.ConnectionContext.Login = UserName;
sqlServer.ConnectionContext.Password = PasswordClearText;
}
else
{
// windows authentication
sqlServer.ConnectionContext.LoginSecure = true;
}
}
sqlServer.ConnectionContext.Connect();
if (sqlServer.ConnectionContext.IsOpen == false)
{
SpecDatabase = null;
ApplicationException ex = new ApplicationException(String.Format(DisplayValues.Exception_SourceDbServerConnection, SourceDbServerName));
Solution.ShowIssue(ex.Message + "\r\n" + ex.StackTrace);
throw ex;
}
if (SourceDbName.Contains("\\"))
{
var dbName = Path.GetFileNameWithoutExtension(SourceDbName);
sqlDatabase = sqlServer.Databases[dbName];
if (sqlDatabase == null)
{
// attach the database instead of opening the database by name
var stringColl = new StringCollection();
stringColl.Add(SourceDbName);
stringColl.Add(Path.Combine(Path.GetDirectoryName(SourceDbName), Path.GetFileNameWithoutExtension(SourceDbName) + "_log.ldf"));
sqlServer.AttachDatabase(dbName, stringColl);
sqlDatabase = sqlServer.Databases[SourceDbName];
}
}
else
{
sqlDatabase = sqlServer.Databases[SourceDbName];
}
if (sqlDatabase == null)
{
SpecDatabase = null;
ApplicationException ex = new ApplicationException(String.Format(DisplayValues.Exception_SourceDbNotFound, SourceDbName, SourceDbServerName));
Solution.ShowIssue(ex.Message + "\r\n" + ex.StackTrace);
throw ex;
}
else
{
// load the database information
SpecDatabase = new SqlDatabase();
SpecDatabase.SqlDatabaseID = Guid.NewGuid();
SpecDatabase.Solution = Solution;
SpecDatabase.LoadSqlServerDatabase(sqlDatabase);
}
break;
case (int)BLL.Config.DatabaseTypeCode.MySQL:
string myConnectionString = "SERVER=" + SourceDbServerName + ";" +
"DATABASE=" + SourceDbName + ";" +
"UID=" + UserName + ";" +
"PASSWORD="******";";
MySqlConnection connection = new MySqlConnection(myConnectionString);
using (connection)
{
try
{
connection.Open();
}
catch
{
SpecDatabase = null;
ApplicationException ex = new ApplicationException(String.Format(DisplayValues.Exception_MySQLConnection, SourceDbName, SourceDbServerName));
Solution.ShowIssue(ex.Message + "\r\n" + ex.StackTrace);
throw;
}
// load the database information
SpecDatabase = new SqlDatabase();
SpecDatabase.SqlDatabaseID = Guid.NewGuid();
SpecDatabase.Solution = Solution;
SpecDatabase.LoadMySQLDatabase(connection);
connection.Close();
}
break;
default:
throw new NotImplementedException("DatabaseTypeCode value " + DatabaseTypeCode + " not implemented!");
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (Exception ex)
{
bool reThrow = BusinessConfiguration.HandleException(ex);
Solution.ShowIssue(ex.ToString());
}
}
public CommandA(BusinessConfiguration businessConfiguration)
{
_businessConfiguration = businessConfiguration;
}
public GetAdminOrUserIdQuery(ILogger logger, BaseDbContext dbContext,
BusinessConfiguration businessConfiguration) : base(logger, dbContext)
{
_businessConfiguration = businessConfiguration;
}
protected BaseDbContext(BusinessConfiguration businessConfiguration)
{
this.businessConfiguration = businessConfiguration;
}
public BaseDbContext(DbContextOptions options, BusinessConfiguration businessConfiguration) : base(options)
{
this.businessConfiguration = businessConfiguration;
}