///--------------------------------------------------------------------------------
        /// <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="keyColumn">The key column row data</param>
        ///--------------------------------------------------------------------------------
        public void LoadMySQLColumn(MySqlConnection sqlConnection, NameObjectCollection variables, DataRow keyColumn)
        {
            try
            {
                // load foreign key  information
                foreach (DataColumn column in keyColumn.Table.Columns)
                {
                    // load important properties into foreign key, the rest as additional sql properties
                    switch (column.ColumnName)
                    {
                    case "COLUMN_NAME":
                        SqlForeignKeyColumnName = keyColumn[column.ColumnName].GetString();
                        break;

                    case "REFERENCED_COLUMN_NAME":
                        ReferencedColumn = keyColumn[column.ColumnName].GetString();
                        break;

                    case "ORDINAL_POSITION":
                        Order = keyColumn[column.ColumnName].GetInt();
                        break;

                    default:
                        SqlProperty property = new SqlProperty();
                        property.SqlPropertyID       = Guid.NewGuid();
                        property.SqlForeignKeyColumn = this;
                        property.LoadMySQLProperty(column.ColumnName, null, keyColumn[column.ColumnName].GetString());
                        SqlPropertyList.Add(property);
                        break;
                    }
                }
            }
            catch (ApplicationAbortException)
            {
                throw;
            }
            catch (Exception ex)
            {
                bool reThrow = BusinessConfiguration.HandleException(ex);
                if (reThrow)
                {
                    throw;
                }
            }
        }
Пример #2
0
        ///--------------------------------------------------------------------------------
        /// <summary>This loads information from a SqlServer database, using SMO.</summary>
        ///
        /// <param name="sqlDatabase">The input sql database</param>
        ///--------------------------------------------------------------------------------
        public void LoadSqlServerDatabase(Database sqlDatabase)
        {
            try
            {
                // load the basic database information
                SqlDatabaseName = sqlDatabase.Name;
                DbID            = sqlDatabase.ID;
                Owner           = sqlDatabase.Owner;
                try
                {
                    PrimaryFilePath        = sqlDatabase.PrimaryFilePath;
                    DefaultFileGroup       = sqlDatabase.DefaultFileGroup;
                    DefaultFullTextCatalog = sqlDatabase.DefaultFullTextCatalog;
                }
                catch
                {
                    // TODO: have specific Azure db load or identify Azure case
                }
                DefaultSchema = sqlDatabase.DefaultSchema;
                CreateDate    = sqlDatabase.CreateDate;
                Status        = sqlDatabase.Status.ToString();
                UserName      = sqlDatabase.UserName;
                State         = sqlDatabase.State.ToString();

                // load information for each property
                foreach (Microsoft.SqlServer.Management.Smo.Property loopProperty in sqlDatabase.Properties)
                {
                    if (DebugHelper.DebugAction == DebugAction.Stop)
                    {
                        return;
                    }
                    if (loopProperty.Expensive == false && loopProperty.IsNull == false && !String.IsNullOrEmpty(loopProperty.Value.ToString()))
                    {
                        SqlProperty property = new SqlProperty();
                        property.SqlPropertyID = Guid.NewGuid();
                        property.SqlDatabase   = this;
                        property.LoadProperty(loopProperty);
                        SqlPropertyList.Add(property);
                    }
                }

                try
                {
                    // load information for each extended property
                    foreach (ExtendedProperty loopProperty in sqlDatabase.ExtendedProperties)
                    {
                        if (DebugHelper.DebugAction == DebugAction.Stop)
                        {
                            return;
                        }
                        SqlExtendedProperty property = new SqlExtendedProperty();
                        property.SqlExtendedPropertyID = Guid.NewGuid();
                        property.SqlDatabase           = this;
                        property.LoadExtendedProperty(loopProperty);
                        SqlExtendedPropertyList.Add(property);
                    }
                }
                catch
                {
                    // TODO: have specific Azure db load or identify Azure case
                }

                // load information for each table
                foreach (Table loopTable in sqlDatabase.Tables)
                {
                    if (loopTable.IsSystemObject == true)
                    {
                        continue;
                    }
                    if (DebugHelper.DebugAction == DebugAction.Stop)
                    {
                        return;
                    }
                    SqlTable table = new SqlTable();
                    table.SqlTableID  = Guid.NewGuid();
                    table.SqlDatabase = this;
                    table.LoadTable(loopTable);
                    SqlTableList.Add(table);
                }

                // load information for each view
                foreach (Microsoft.SqlServer.Management.Smo.View loopView in sqlDatabase.Views)
                {
                    if (loopView.IsSystemObject == true)
                    {
                        continue;
                    }
                    SqlView view = new SqlView();
                    view.SqlViewID   = Guid.NewGuid();
                    view.SqlDatabase = this;
                    view.LoadView(loopView);
                    SqlViewList.Add(view);
                }
            }
            catch (ApplicationAbortException)
            {
                throw;
            }
            catch (Exception)
            {
                throw;
            }
        }
Пример #3
0
        ///--------------------------------------------------------------------------------
        /// <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;
                }
            }
        }
Пример #4
0
        ///--------------------------------------------------------------------------------
        /// <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;
                }
            }
        }
Пример #5
0
        ///--------------------------------------------------------------------------------
        /// <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;
                }
            }
        }
Пример #6
0
        ///--------------------------------------------------------------------------------
        /// <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;
                }
            }
        }
Пример #7
0
        ///--------------------------------------------------------------------------------
        /// <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;
                }
            }
        }
Пример #8
0
        ///--------------------------------------------------------------------------------
        /// <summary>This loads information from a MySQL table.</summary>
        ///
        /// <param name="sqlConnection">The input sql connection</param>
        /// <param name="variables">Database level variables</param>
        /// <param name="table">The table row data</param>
        /// <param name="columns">The columns table data</param>
        /// <param name="indexes">The indexes table data</param>
        /// <param name="indexColumns">The index columns table data</param>
        /// <param name="keys">The keys table data</param>
        /// <param name="keyColumns">The key columns table data</param>
        ///--------------------------------------------------------------------------------
        public void LoadMySQLTable(MySqlConnection sqlConnection, NameObjectCollection variables, DataRow table, DataTable columns, DataTable indexes, DataTable indexColumns, DataTable keys, DataTable keyColumns)
        {
            try
            {
                // load table information
                foreach (DataColumn column in table.Table.Columns)
                {
                    // load important properties into table, the rest as additional sql properties
                    switch (column.ColumnName)
                    {
                    case "TABLE_NAME":
                        SqlTableName = table[column.ColumnName].GetString();
                        break;

                    case "CREATE_TIME":
                        CreateDate = table[column.ColumnName].GetDateTime();
                        break;

                    case "UPDATE_TIME":
                        DateLastModified = table[column.ColumnName].GetDateTime();
                        break;

                    default:
                        SqlProperty property = new SqlProperty();
                        property.SqlPropertyID = Guid.NewGuid();
                        property.SqlTable      = this;
                        property.LoadMySQLProperty(column.ColumnName, null, table[column.ColumnName].GetString());
                        SqlPropertyList.Add(property);
                        break;
                    }
                }

                // load information for each column
                if (columns != null)
                {
                    foreach (DataRow row in columns.Rows)
                    {
                        if (DebugHelper.DebugAction == DebugAction.Stop)
                        {
                            return;
                        }
                        if (row["TABLE_NAME"].GetString() == SqlTableName)
                        {
                            SqlColumn column = new SqlColumn();
                            column.SqlColumnID = Guid.NewGuid();
                            column.SqlTable    = this;
                            column.LoadMySQLColumn(sqlConnection, variables, row);
                            SqlColumnList.Add(column);
                        }
                    }
                }

                // load information for each index
                if (indexes != null)
                {
                    foreach (DataRow row in indexes.Rows)
                    {
                        if (DebugHelper.DebugAction == DebugAction.Stop)
                        {
                            return;
                        }
                        if (row["TABLE_NAME"].GetString() == SqlTableName)
                        {
                            SqlIndex index = new SqlIndex();
                            index.SqlIndexID = Guid.NewGuid();
                            index.SqlTable   = this;
                            index.LoadMySQLIndex(sqlConnection, variables, row, indexColumns);
                            SqlIndexList.Add(index);
                        }
                    }
                }

                // load information for each foreign key
                if (keys != null)
                {
                    foreach (DataRow row in keys.Rows)
                    {
                        if (DebugHelper.DebugAction == DebugAction.Stop)
                        {
                            return;
                        }
                        if (row["table_name"].GetString() == SqlTableName)
                        {
                            SqlForeignKey key = new SqlForeignKey();
                            key.SqlForeignKeyID = Guid.NewGuid();
                            key.SqlTable        = this;
                            key.LoadMySQLForeignKey(sqlConnection, variables, row, keyColumns);
                            SqlForeignKeyList.Add(key);
                        }
                    }
                }
            }
            catch (ApplicationAbortException)
            {
                throw;
            }
            catch (Exception)
            {
                throw;
            }
        }
Пример #9
0
        ///--------------------------------------------------------------------------------
        /// <summary>This loads information from a SQL table.</summary>
        ///
        /// <param name="sqlTable">The input sql table.</param>
        ///--------------------------------------------------------------------------------
        public void LoadTable(Table sqlTable)
        {
            try
            {
                // load the basic table information
                SqlTableName = sqlTable.Name;
                DbID         = sqlTable.ID;
                Owner        = sqlTable.Owner;
                Schema       = sqlTable.Schema;
                try
                {
                    FileGroup = sqlTable.FileGroup;
                }
                catch
                {
                    // TODO: have specific Azure db load or identify Azure case
                }
                CreateDate       = sqlTable.CreateDate;
                DateLastModified = sqlTable.DateLastModified;
                Urn   = sqlTable.Urn;
                State = sqlTable.State.ToString();

                // load information for each property
                foreach (Microsoft.SqlServer.Management.Smo.Property loopProperty in sqlTable.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 == "RowCount" || loopProperty.Name == "HasClusteredIndex" || loopProperty.Name == "HasIndex")
                        {
                            SqlProperty property = new SqlProperty();
                            property.SqlPropertyID = Guid.NewGuid();
                            property.SqlTable      = this;
                            property.LoadProperty(loopProperty);
                            SqlPropertyList.Add(property);
                        }
                    }
                }

                try
                {
                    // load information for each extended property
                    foreach (ExtendedProperty loopProperty in sqlTable.ExtendedProperties)
                    {
                        if (DebugHelper.DebugAction == DebugAction.Stop)
                        {
                            return;
                        }
                        SqlExtendedProperty property = new SqlExtendedProperty();
                        property.SqlExtendedPropertyID = Guid.NewGuid();
                        property.SqlTable = this;
                        property.LoadExtendedProperty(loopProperty);
                        SqlExtendedPropertyList.Add(property);
                    }
                }
                catch
                {
                    // TODO: have specific Azure db load or identify Azure case
                }

                // load information for each column
                foreach (Column loopColumn in sqlTable.Columns)
                {
                    if (DebugHelper.DebugAction == DebugAction.Stop)
                    {
                        return;
                    }
                    SqlColumn column = new SqlColumn();
                    column.SqlColumnID = Guid.NewGuid();
                    column.SqlTable    = this;
                    column.LoadColumn(loopColumn);
                    SqlColumnList.Add(column);
                }

                // load information for each index
                foreach (Index loopIndex in sqlTable.Indexes)
                {
                    if (DebugHelper.DebugAction == DebugAction.Stop)
                    {
                        return;
                    }
                    SqlIndex index = new SqlIndex();
                    index.SqlIndexID = Guid.NewGuid();
                    index.SqlTable   = this;
                    index.LoadIndex(loopIndex);
                    SqlIndexList.Add(index);
                }

                // load information for each foreign key
                foreach (ForeignKey loopKey in sqlTable.ForeignKeys)
                {
                    if (DebugHelper.DebugAction == DebugAction.Stop)
                    {
                        return;
                    }
                    SqlForeignKey key = new SqlForeignKey();
                    key.SqlForeignKeyID = Guid.NewGuid();
                    key.SqlTable        = this;
                    key.LoadForeignKey(loopKey);
                    SqlForeignKeyList.Add(key);
                }
            }
            catch (ApplicationAbortException)
            {
                throw;
            }
            catch (Exception)
            {
                throw;
            }
        }
Пример #10
0
        ///--------------------------------------------------------------------------------
        /// <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;
                }
            }
        }
Пример #11
0
        ///--------------------------------------------------------------------------------
        /// <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;
                }
            }
        }