private async void ShowColumnMappingSelector(string referenceTableName, List <ForeignKeyColumn> mappings)
        {
            frmColumnMapping form = new frmColumnMapping()
            {
                ReferenceTableName = referenceTableName, TableName = this.txtTableName.Text.Trim(), Mappings = mappings
            };

            IEnumerable <TableColumnDesingerInfo> columns = this.ucColumns.GetColumns().Where(item => !string.IsNullOrEmpty(item.Name));

            form.TableColumns = columns.OrderBy(item => item.Name).Select(item => item.Name).ToList();

            DbInterpreter dbInterpreter = this.GetDbInterpreter();

            dbInterpreter.Option.ObjectFetchMode = DatabaseObjectFetchMode.Simple;

            SchemaInfoFilter filter = new SchemaInfoFilter()
            {
                TableNames = new string[] { referenceTableName }
            };
            List <TableColumn> referenceTableColumns = await dbInterpreter.GetTableColumnsAsync(filter);

            if (referenceTableName == this.selfTableName)
            {
                form.ReferenceTableColumns = this.ucColumns.GetColumns().Select(item => item.Name).ToList();
            }
            else
            {
                form.ReferenceTableColumns = referenceTableColumns.Select(item => item.Name).ToList();
            }

            if (form.ShowDialog() == DialogResult.OK)
            {
                this.ucForeignKeys.SetRowColumns(form.Mappings);
            }
        }
        public virtual async Task <DiagnoseResult> DiagnoseNotNullWithEmpty()
        {
            this.Feedback("Begin to diagnose not null fields with empty value...");

            DiagnoseResult result = new DiagnoseResult();

            DbInterpreterOption option = new DbInterpreterOption()
            {
                ObjectFetchMode = DatabaseObjectFetchMode.Simple
            };

            DbInterpreter interpreter = DbInterpreterHelper.GetDbInterpreter(this.DatabaseType, this.connectionInfo, option);

            this.Feedback("Begin to get table columns...");

            List <TableColumn> columns = await interpreter.GetTableColumnsAsync();

            this.Feedback("End get table columns.");

            var groups = columns.Where(item => DataTypeHelper.IsCharType(item.DataType) && !item.IsNullable)
                         .GroupBy(item => new { item.Owner, item.TableName });

            using (DbConnection dbConnection = interpreter.CreateConnection())
            {
                foreach (var group in groups)
                {
                    foreach (TableColumn column in group)
                    {
                        string countSql = this.GetTableColumnEmptySql(interpreter, column, true);

                        this.Feedback($@"Begin to get invalid record count for column ""{column.Name}"" of table ""{column.TableName}""...");

                        int count = Convert.ToInt32(await interpreter.GetScalarAsync(dbConnection, countSql));

                        this.Feedback($@"End get invalid record count for column ""{column.Name}"" of table ""{column.TableName}"", the count is {count}.");

                        if (count > 0)
                        {
                            result.Details.Add(new DiagnoseResultItem()
                            {
                                DatabaseObject = column,
                                RecordCount    = count,
                                Sql            = this.GetTableColumnEmptySql(interpreter, column, false)
                            });
                        }
                    }
                }
            }

            this.Feedback("End diagnose not null fields with empty value.");

            return(result);
        }