private TreeNodeCollection AddTreeNodes <T>(TreeNode node, DatabaseObjectType types, DatabaseObjectType type, List <T> dbObjects, bool createFolderNode = true, bool createFakeNode = false)
where T : DatabaseObject
{
TreeNode targetNode = node;
if (types.HasFlag(type))
{
if (createFolderNode)
{
targetNode = node.AddDbObjectFolderNode(dbObjects);
}
else
{
targetNode = node.AddDbObjectNodes(dbObjects);
}
}
if (createFakeNode && targetNode != null)
{
foreach (TreeNode child in targetNode.Nodes)
{
child.Nodes.Add(DbObjectsTreeHelper.CreateFakeNode());
}
}
return(node.Nodes);
}
private async Task AddDbObjectNodes(TreeNode parentNode, string database, DatabaseObjectType databaseObjectType = DatabaseObjectType.None, bool createFolderNode = true)
{
DbInterpreter dbInterpreter = this.GetDbInterpreter(database);
SchemaInfo schemaInfo = databaseObjectType == DatabaseObjectType.None ? new SchemaInfo() :
await dbInterpreter.GetSchemaInfoAsync(new SchemaInfoFilter()
{
DatabaseObjectType = databaseObjectType
});
this.ClearNodes(parentNode);
this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Table, schemaInfo.Tables, createFolderNode, true);
this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.View, schemaInfo.Views, createFolderNode);
this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Function, schemaInfo.Functions, createFolderNode);
this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Procedure, schemaInfo.Procedures, createFolderNode);
foreach (UserDefinedType userDefinedType in schemaInfo.UserDefinedTypes)
{
string text = $"{userDefinedType.Name}({userDefinedType.Type})";
string imageKeyName = nameof(userDefinedType);
TreeNode node = DbObjectsTreeHelper.CreateTreeNode(userDefinedType.Name, text, imageKeyName);
node.Tag = userDefinedType;
parentNode.Nodes.Add(node);
}
}
private void AddDatabaseFakeNodes(TreeNode databaseNode, Database database)
{
this.ClearNodes(databaseNode);
databaseNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Tables), nameof(DbObjectTreeFolderType.Tables), true));
databaseNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Views), nameof(DbObjectTreeFolderType.Views), true));
databaseNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Functions), nameof(DbObjectTreeFolderType.Functions), true));
databaseNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Procedures), nameof(DbObjectTreeFolderType.Procedures), true));
}
private void AddTableFakeNodes(TreeNode tableNode, Table table)
{
this.ClearNodes(tableNode);
tableNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Columns), nameof(DbObjectTreeFolderType.Columns), true));
tableNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Triggers), nameof(DbObjectTreeFolderType.Triggers), true));
tableNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Indexes), nameof(DbObjectTreeFolderType.Indexes), true));
tableNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Keys), nameof(DbObjectTreeFolderType.Keys), true));
tableNode.Nodes.Add(DbObjectsTreeHelper.CreateFolderNode(nameof(DbObjectTreeFolderType.Constraints), nameof(DbObjectTreeFolderType.Constraints), true));
}
private void ShowLoading(TreeNode node)
{
string loadingImageKey = "Loading.gif";
string loadingText = "loading...";
if (this.IsOnlyHasFakeChild(node))
{
node.Nodes[0].ImageKey = loadingImageKey;
node.Nodes[0].Text = loadingText;
}
else
{
node.Nodes.Add(DbObjectsTreeHelper.CreateTreeNode("Loading", loadingText, loadingImageKey));
}
}
public async Task LoadTree(DatabaseType dbType, ConnectionInfo connectionInfo)
{
this.databaseType = dbType;
this.connectionInfo = connectionInfo;
this.tvDbObjects.Nodes.Clear();
DbInterpreter dbInterpreter = DbInterpreterHelper.GetDbInterpreter(dbType, connectionInfo, simpleInterpreterOption);
List <Database> databases = await dbInterpreter.GetDatabasesAsync();
foreach (Database database in databases)
{
TreeNode node = DbObjectsTreeHelper.CreateTreeNode(database, true);
this.tvDbObjects.Nodes.Add(node);
}
if (this.tvDbObjects.Nodes.Count == 1)
{
this.tvDbObjects.SelectedNode = this.tvDbObjects.Nodes[0];
this.tvDbObjects.Nodes[0].Expand();
}
}
private async Task LoadChildNodes(TreeNode node)
{
this.ShowLoading(node);
object tag = node.Tag;
if (tag is Database)
{
Database database = tag as Database;
this.AddDatabaseFakeNodes(node, database);
}
else if (tag is Table)
{
Table table = tag as Table;
this.AddTableFakeNodes(node, table);
}
else if (tag == null)
{
string name = node.Name;
TreeNode parentNode = node.Parent;
if (parentNode.Tag is Database)
{
string databaseName = parentNode.Name;
DatabaseObjectType databaseObjectType = DbObjectsTreeHelper.GetDbObjectTypeByFolderName(name);
if (databaseObjectType != DatabaseObjectType.None)
{
await this.AddDbObjectNodes(node, databaseName, databaseObjectType, false);
}
}
else if (parentNode.Tag is Table)
{
DatabaseObjectType databaseObjectType = DatabaseObjectType.None;
switch (name)
{
case nameof(DbObjectTreeFolderType.Columns):
databaseObjectType = DatabaseObjectType.TableColumn | DatabaseObjectType.TablePrimaryKey | DatabaseObjectType.TableForeignKey;
break;
case nameof(DbObjectTreeFolderType.Triggers):
databaseObjectType = DatabaseObjectType.TableTrigger;
break;
case nameof(DbObjectTreeFolderType.Indexes):
databaseObjectType = DatabaseObjectType.TableIndex;
break;
case nameof(DbObjectTreeFolderType.Keys):
databaseObjectType = DatabaseObjectType.TablePrimaryKey | DatabaseObjectType.TableForeignKey;
break;
case nameof(DbObjectTreeFolderType.Constraints):
databaseObjectType = DatabaseObjectType.TableConstraint;
break;
}
await this.AddTableObjectNodes(node, parentNode.Tag as Table, databaseObjectType);
}
}
}
private async Task AddTableObjectNodes(TreeNode treeNode, Table table, DatabaseObjectType databaseObjectType)
{
string nodeName = treeNode.Name;
string database = this.GetDatabaseNode(treeNode).Name;
DbInterpreter dbInterpreter = this.GetDbInterpreter(database, false);
dbInterpreter.Subscribe(this);
SchemaInfo schemaInfo = await dbInterpreter.GetSchemaInfoAsync(new SchemaInfoFilter()
{
Strict = true, DatabaseObjectType = databaseObjectType, TableNames = new string[] { table.Name }
});
this.ClearNodes(treeNode);
#region Columns
if (nodeName == nameof(DbObjectTreeFolderType.Columns))
{
foreach (TableColumn column in schemaInfo.TableColumns)
{
string text = this.GetColumnText(dbInterpreter, table, column);
bool isPrimaryKey = schemaInfo.TablePrimaryKeys.Any(item => item.Columns.Any(t => t.ColumnName == column.Name));
bool isForeignKey = schemaInfo.TableForeignKeys.Any(item => item.Columns.Any(t => t.ColumnName == column.Name));
string imageKeyName = isPrimaryKey ? nameof(TablePrimaryKey) : (isForeignKey ? nameof(TableForeignKey) : nameof(TableColumn));
TreeNode node = DbObjectsTreeHelper.CreateTreeNode(column.Name, text, imageKeyName);
node.Tag = column;
treeNode.Nodes.Add(node);
}
}
#endregion
if (nodeName == nameof(DbObjectTreeFolderType.Triggers))
{
treeNode.AddDbObjectNodes(schemaInfo.TableTriggers);
}
#region Indexes
if (nodeName == nameof(DbObjectTreeFolderType.Indexes) && schemaInfo.TableIndexes.Any())
{
foreach (TableIndex index in schemaInfo.TableIndexes)
{
bool isUnique = index.IsUnique;
string strColumns = string.Join(",", index.Columns.OrderBy(item => item.Order).Select(item => item.ColumnName));
string content = isUnique ? $"(Unique, {strColumns})" : $"({strColumns})";
string text = $"{index.Name}{content}";
string imageKeyName = nameof(TableIndex);
TreeNode node = DbObjectsTreeHelper.CreateTreeNode(index.Name, text, imageKeyName);
node.Tag = index;
treeNode.Nodes.Add(node);
}
}
#endregion
if (nodeName == nameof(DbObjectTreeFolderType.Keys))
{
foreach (TablePrimaryKey key in schemaInfo.TablePrimaryKeys)
{
TreeNode node = DbObjectsTreeHelper.CreateTreeNode(key);
treeNode.Nodes.Add(node);
}
foreach (TableForeignKey key in schemaInfo.TableForeignKeys)
{
TreeNode node = DbObjectsTreeHelper.CreateTreeNode(key);
treeNode.Nodes.Add(node);
}
}
#region Constraints
if (nodeName == nameof(DbObjectTreeFolderType.Constraints) && schemaInfo.TableConstraints.Any())
{
foreach (TableConstraint constraint in schemaInfo.TableConstraints)
{
TreeNode node = DbObjectsTreeHelper.CreateTreeNode(constraint);
treeNode.Nodes.Add(node);
}
}
#endregion
this.Feedback("");
}
