public EntityClassBuilder(ApplicationCommand cmd, TableName tname)
: base(cmd)
{
this.tname = tname;
this.SetClassName(tname.ToClassName(rule: null));
builder.AddUsing("System");
builder.AddUsing("System.Collections.Generic");
builder.AddUsing("System.Data");
builder.AddUsing("System.Linq");
AddOptionalUsing();
IsAssocication = Associate();
}
private bool Display(ApplicationCommand cmd, DataTable table, int top)
{
try
{
uniqueTable = new UniqueTable(tname, table);
_DisplayTable(uniqueTable, top > 0 && table.Rows.Count == top, cmd);
}
catch (Exception ex)
{
cerr.WriteLine(ex.Message);
return(false);
}
return(true);
}
private bool Display(ApplicationCommand cmd, SqlBuilder builder, TableName tname, int top)
{
try
{
DataTable table = builder.SqlCmd.FillDataTable();
table.SetSchemaAndTableName(tname);
ShellHistory.SetLastResult(table);
return(Display(cmd, table, top));
}
catch (Exception ex)
{
cerr.WriteLine(ex.Message);
return(false);
}
}
public bool TypeFile(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (TypeFileData(pt, cmd))
{
return(true);
}
if (TypeLocatorData(pt, cmd))
{
return(true);
}
if (TypeLocatorColumnData(pt, cmd))
{
return(true);
}
return(false);
}
private static bool DisplayDatabaseNodes(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (!(pt.Item is ServerName))
{
return(false);
}
ServerName sname = (ServerName)pt.Item;
if (sname.Disconnected)
{
cout.WriteLine("\t? Database(s)");
}
else
{
int i = 0;
int count = 0;
int h = 0;
List <string> values = new List <string>();
foreach (var node in pt.Nodes)
{
DatabaseName dname = (DatabaseName)node.Item;
++i;
if (IsMatch(cmd.wildcard, dname.Path))
{
count++;
if (node.Nodes.Count == 0)
{
ExpandDatabaseName(node, cmd.Refresh);
}
cout.WriteLine("{0,4} {1,26} <DB> {2,10} Tables/Views", sub(i), dname.Name, node.Nodes.Count);
h = PagePause(cmd, ++h);
values.Add(dname.Name);
}
}
Assign(cmd, values);
cout.WriteLine("\t{0} Database(s)", count);
}
return(true);
}
private bool DisplayServerNodes(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (pt != RootNode)
{
return(false);
}
int i = 0;
int count = 0;
int h = 0;
CancelableWork.CanCancel(cts =>
{
List <string> values = new List <string>();
foreach (var node in pt.Nodes)
{
if (cts.IsCancellationRequested)
{
return;
}
ServerName sname = (ServerName)node.Item;
++i;
if (IsMatch(cmd.wildcard, sname.Path))
{
count++;
if (node.Nodes.Count == 0)
{
ExpandServerName(node, Refreshing);
}
cout.WriteLine("{0,4} {1,26} <SVR> {2,10} Databases", sub(i), sname.Path, sname.Disconnected ? "?" : node.Nodes.Count.ToString());
h = PagePause(cmd, ++h);
values.Add(sname.Path);
}
}
Assign(cmd, values);
cout.WriteLine("\t{0} Server(s)", count);
});
return(true);
}
private static void Assign(ApplicationCommand cmd, IEnumerable <string> values)
{
string vname = cmd.GetValue("let");
if (vname == null)
{
return;
}
if (vname == string.Empty)
{
cerr.WriteLine("undefined variable name");
return;
}
string[] A = values.ToArray();
Context.DS.Add(vname, new VAL(A));
}
private static bool DisplayViewNodes(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (!(pt.Item is TableName))
{
return(false);
}
TableName vname = (TableName)pt.Item;
if (vname.Type != TableNameType.View)
{
return(false);
}
DataTable schema = vname.ViewSchema();
cout.WriteLine("VIEW: {0}", vname.Path);
int i = 0;
int count = 0;
int h = 0;
foreach (DataRow row in schema.Rows)
{
string columnName = string.Format("{0}", row["COLUMN_NAME"]);
if (IsMatch(cmd.wildcard, columnName))
{
count++;
cout.WriteLine("{0,5} {1,26} {2,-16} {3,10}",
sub(++i),
string.Format("{0}", columnName),
row["DATA_TYPE"],
(string)row["IS_NULLABLE"] == "YES" ? "null" : "not null");
h = PagePause(cmd, ++h);
}
}
cout.WriteLine("\t{0} Column(s)", count);
return(true);
}
private TableName[] getTableNames(ApplicationCommand cmd)
{
TableName[] tnames;
if (cmd.wildcard != null)
{
var md = new MatchedDatabase(dname, cmd);
tnames = md.TableNames();
if (tnames.Length == 0)
{
cerr.WriteLine("warning: no table is matched");
return(new TableName[] { });
}
}
else
{
tnames = dname.GetTableNames();
}
return(tnames);
}
private bool TypeLocatorData(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (!(pt.Item is Locator))
{
return(false);
}
TableName tname = this.GetCurrentPath <TableName>();
Locator locator = GetCombinedLocator(pt);
var xnode = pt;
while (xnode.Parent.Item is Locator)
{
xnode = xnode.Parent;
locator.And((Locator)xnode.Item);
}
tout = new TableOut(tname);
return(tout.Display(cmd, "*", locator));
}
public TreeNode <IDataPath> TryAddWhereOrColumns(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (!(pt.Item is Locator) && !(pt.Item is TableName))
{
return(pt);
}
if (string.IsNullOrEmpty(cmd.arg1))
{
cerr.WriteLine("argument cannot be empty");
}
TableName tname = GetCurrentPath <TableName>();
var locator = new Locator(cmd.arg1)
{
Name = cmd.GetValue("name")
};
if (locator.Name == null)
{
locator.Name = $"filter{pt.Nodes.Count + 1}";
}
var builder = new SqlBuilder().SELECT().TOP(1).COLUMNS().FROM(tname).WHERE(locator);
if (builder.Invalid())
{
cerr.WriteLine($"invalid path: {cmd.arg1}");
return(pt);
}
var xnode = new TreeNode <IDataPath>(locator);
pt.Nodes.Add(xnode);
return(xnode);
}
public Exporter(PathManager mgr, TreeNode <IDataPath> pt, ApplicationCommand cmd, IApplicationConfiguration cfg)
{
this.mgr = mgr;
this.cmd = cmd;
this.cfg = cfg;
this.xmlDbFile = new XmlDbCreator
{
XmlDbFolder = cfg.XmlDbDirectory
};
if (pt.Item is Locator)
{
this.tname = mgr.GetPathFrom <TableName>(pt);
this.dname = tname.DatabaseName;
this.sname = dname.ServerName;
}
else if (pt.Item is TableName)
{
this.tname = (TableName)pt.Item;
this.dname = tname.DatabaseName;
this.sname = dname.ServerName;
}
else if (pt.Item is DatabaseName)
{
this.tname = null;
this.dname = (DatabaseName)pt.Item;
this.sname = dname.ServerName;
}
else if (pt.Item is ServerName)
{
this.tname = null;
this.dname = null;
this.sname = (ServerName)pt.Item;
}
}
private bool TypeLocatorColumnData(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (!(pt.Item is ColumnPath))
{
return(false);
}
ColumnPath column = (ColumnPath)pt.Item;
Locator locator = null;
TableName tname = null;
if (pt.Parent.Item is Locator)
{
locator = (Locator)pt.Parent.Item;
tname = (TableName)pt.Parent.Parent.Item;
}
else
{
tname = (TableName)pt.Parent.Item;
}
tout = new TableOut(tname);
return(tout.Display(cmd, column.Columns, locator));
}
public DataClassBuilder(ApplicationCommand cmd, DataTable dt)
: base(cmd)
{
this.cmd = cmd;
this.dt = dt;
}
public Loader(ApplicationCommand cmd)
{
this.cmd = cmd;
}
public string Run(ActionType compareType, TableName[] N1, TableName[] N2, ApplicationCommand cmd)
{
string[] exceptColumns = cmd.Columns;
DatabaseName dname1 = Side1.DatabaseName;
DatabaseName dname2 = Side2.DatabaseName;
cout.WriteLine("server1: {0} default database:{1}", Side1.Provider.DataSource, dname1.Name);
cout.WriteLine("server2: {0} default database:{1}", Side2.Provider.DataSource, dname2.Name);
if (!Exists(dname1) || !Exists(dname2))
{
return(string.Empty);
}
StringBuilder builder = new StringBuilder();
builder.AppendFormat("-- sqlcon:", Side1.Provider.DataSource, dname1.Name).AppendLine();
builder.AppendFormat("-- compare server={0} db={1}", Side1.Provider.DataSource, dname1.Name).AppendLine();
builder.AppendFormat("-- server={0} db={1} @ {2}", Side2.Provider.DataSource, dname2.Name, DateTime.Now).AppendLine();
Wildcard <TableName> match = MatchedDatabase.CreateWildcard(cmd);
CancelableWork.CanCancel(cts =>
{
int i = 0;
foreach (var tname1 in N1)
{
if (cts.IsCancellationRequested)
{
return;
}
TableName tname2 = N2.Where(t => t.Name == tname1.Name).FirstOrDefault();
if (tname2 == null)
{
//when compare tables in the same database, the table name could be different
if (i < N2.Length && N2[i].DatabaseName == tname1.DatabaseName)
{
tname2 = N2[i];
}
else
{
tname2 = new TableName(dname2, tname1.SchemaName, tname1.Name);
}
}
if (compareType == ActionType.CompareData && !match.Contains(tname1))
{
cout.WriteLine("{0} is excluded", tname1);
continue;
}
if (tname2.Exists())
{
try
{
builder.Append(CompareTable(compareType, CompareSideType.compare, tname1, tname2, cmd.PK, exceptColumns));
}
catch (Exception ex)
{
cerr.WriteLine(ex.Message);
}
}
else
{
if (compareType == ActionType.CompareSchema)
{
string sql = tname1.GenerateCreateTableClause(appendGO: false);
cout.WriteLine(sql);
builder
.Append(sql)
.AppendLine(SqlScript.GO);
}
else
{
cout.WriteLine("{0} doesn't exist", tname2);
}
}
i++;
}
});
return(builder.ToString());
}
public MatchedDatabase(DatabaseName databaseName, ApplicationCommand cmd)
: this(databaseName, cmd.wildcard)
{
this.Includedtables = cmd.Includes;
this.Excludedtables = cmd.Excludes;
}
private bool TypeFileData(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (pt.Item is ServerName)
{
ServerName sname = (ServerName)pt.Item;
//display all tables in the database server, when type of server is DbFile
if (sname.Provider.Type == ConnectionProviderType.DbFile)
{
int index = 1;
foreach (DatabaseName dname in sname.GetDatabaseNames())
{
cout.WriteLine();
cout.WriteLine($"({index++}) {dname.Name}");
foreach (TableName tname in dname.GetTableNames())
{
cout.WriteLine($"[{tname.ShortName}]");
tout = new TableOut(tname);
tout.Display(cmd);
}
}
return(true);
}
}
if (pt.Item is DatabaseName)
{
DatabaseName dname = (DatabaseName)pt.Item;
foreach (TableName tname in dname.GetTableNames())
{
cout.WriteLine();
cout.WriteLine($"[{tname.ShortName}]");
tout = new TableOut(tname);
tout.Display(cmd);
}
return(true);
}
if (pt.Item is TableName)
{
TableName tname = (TableName)pt.Item;
if (tname.Type == TableNameType.Table || tname.Type == TableNameType.View)
{
tout = new TableOut(tname);
return(tout.Display(cmd));
}
else
{
string code = tname.DatabaseName.GetProcedure(tname);
if (!string.IsNullOrEmpty(code))
{
cout.WriteLine(code);
return(true);
}
}
}
return(false);
}
private static bool DisplayTableNodes(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (!(pt.Item is DatabaseName))
{
return(false);
}
DatabaseName dname = (DatabaseName)pt.Item;
if (cmd.HasStorage)
{
displayTable(dname.StorageSchema(), "Storage");
return(true);
}
int i = 0;
int[] count = new int[] { 0, 0, 0, 0 };
int h = 0;
List <string> values = new List <string>();
foreach (var node in pt.Nodes)
{
TableName tname = (TableName)node.Item;
++i;
if (IsMatch(cmd.wildcard, tname.Path) || (tname.SchemaName == SchemaName.dbo && IsMatch(cmd.wildcard, tname.Name)))
{
string desc = "TABLE";
switch (tname.Type)
{
case TableNameType.Table:
desc = "TABLE";
count[0]++;
break;
case TableNameType.View:
desc = "VIEW";
count[1]++;
break;
case TableNameType.Procedure:
desc = "PROC";
count[2]++;
break;
case TableNameType.Function:
desc = "FUNC";
count[3]++;
break;
}
cout.WriteLine("{0,5} {1,15}.{2,-37} <{3}>", sub(i), tname.SchemaName, tname.Name, desc);
h = PagePause(cmd, ++h);
values.Add(tname.ShortName);
}
}
Assign(cmd, values);
cout.WriteLine("\t{0} Table(s)", count[0]);
cout.WriteLine("\t{0} View(s)", count[1]);
cout.WriteLine("\t{0} Procedure(s)", count[2]);
cout.WriteLine("\t{0} Function(s)", count[3]);
return(true);
}
private static bool DisplayTableSubNodes(TreeNode <IDataPath> pt, ApplicationCommand cmd)
{
if (!(pt.Item is TableName))
{
return(false);
}
TableName tname = (TableName)pt.Item;
bool flag = false;
if (cmd.HasDefinition)
{
if (tname.Type == TableNameType.View)
{
cout.WriteLine("cannot display view structure");
return(false);
}
_DisplayColumnNodes(cmd, tname);
return(true);
}
if (cmd.HasPrimaryKey)
{
displayTable(tname.PrimaryKeySchema(), "Primary Key(s)");
flag = true;
}
if (cmd.HasForeignKey)
{
displayTable(tname.ForeignKeySchema(), "Foreign Key(s)");
flag = true;
}
if (cmd.HasDependency)
{
displayTable(tname.DependenySchema(), "Dependencies");
flag = true;
}
if (cmd.HasIdentityKey)
{
displayTable(tname.IdentityKeySchema(), "Identity Key(s)");
flag = true;
}
if (cmd.HasIndex)
{
displayTable(tname.IndexSchema(), "Indices");
flag = true;
}
if (cmd.HasStorage)
{
displayTable(tname.StorageSchema(), "Storage");
flag = true;
}
if (flag)
{
return(true);
}
_DisplayLocatorNodes(pt, cmd);
return(true);
}
private static void _DisplayColumnNodes(ApplicationCommand cmd, TableName tname)
{
TableSchema schema = new TableSchema(tname);
cout.WriteLine("TABLE: {0}", tname.Path);
bool hasJson = cmd.Has("json");
VAL lines = new VAL();
int i = 0;
int count = 0;
int h = 0;
foreach (IColumn column in schema.Columns)
{
if (IsMatch(cmd.wildcard, column.ColumnName))
{
count++;
List <string> L = new List <string>();
if (column.IsIdentity)
{
L.Add("++");
}
if (column.IsPrimary)
{
L.Add("pk");
}
string fk = string.Empty;
ColumnSchema col = column as ColumnSchema;
if (col.IsForeignKey)
{
L.Add("fk");
if (cmd.HasForeignKey)
{
fk = $"-> {col.PK_Schema}.[{col.PK_Table}].[{col.PK_Column}]";
}
}
string keys = string.Join(",", L);
if (!hasJson)
{
cout.WriteLine("{0,5} {1,26} {2,-16} {3,10} {4,10} {5}",
sub(++i),
string.Format("[{0}]", column.ColumnName),
column.GetSQLType(),
keys,
column.Nullable ? "null" : "not null",
fk);
}
else
{
VAL line = new VAL();
if (keys != "")
{
line.AddMember("Key", keys);
}
line.AddMember("Column", column.ColumnName);
line.AddMember("Type", column.GetSQLType());
if (column.Nullable)
{
line.AddMember("Null", column.Nullable);
}
lines.Add(line);
}
h = PagePause(cmd, ++h);
}
}
if (!hasJson)
{
cout.WriteLine("\t{0} Column(s)", count);
}
else
{
cout.WriteLine(lines.ToJson());
}
}
public PathSide(PathManager mgr, ApplicationCommand cmd)
{
this.mgr = mgr;
this.cmd = cmd;
}
public TheClassBuilder(ApplicationCommand cmd)
: base(cmd)
{
builder = new CSharpBuilder();
}
public ClassMaker(ApplicationCommand cmd)
{
this.cmd = cmd;
}
private NextStep DoSingleLineCommand(string line)
{
line = line.Trim();
if (line == string.Empty)
{
return(NextStep.CONTINUE);
}
ApplicationCommand cmd = new ApplicationCommand(cfg, line);
if (cmd.badcommand)
{
return(NextStep.ERROR);
}
switch (cmd.Action)
{
case "set":
commandee.set(cmd);
return(NextStep.COMPLETED);
case "let":
commandee.let(cmd);
return(NextStep.COMPLETED);
case "md":
case "mkdir":
commandee.mkdir(cmd);
return(NextStep.COMPLETED);
case "rd":
case "rmdir":
commandee.rmdir(cmd);
return(NextStep.COMPLETED);
}
switch (cmd.Action)
{
case "ls":
case "dir":
commandee.dir(cmd);
return(NextStep.COMPLETED);
case "cd":
case "chdir":
if (cmd.arg1 != null || cmd.HasHelp)
{
chdir(cmd);
}
else
{
cout.WriteLine(mgr.ToString());
}
return(NextStep.COMPLETED);
case "type":
commandee.type(cmd);
return(NextStep.COMPLETED);
case "del":
case "erase":
commandee.del(cmd);
return(NextStep.COMPLETED);
case "ren":
case "rename":
commandee.rename(cmd);
return(NextStep.COMPLETED);
case "attrib":
commandee.attrib(cmd);
return(NextStep.COMPLETED);
case "echo":
commandee.echo(cmd);
return(NextStep.COMPLETED);
case "rem":
return(NextStep.COMPLETED);
case "ver":
cout.WriteLine("sqlcon [Version {0}]", Helper.ApplicationVerison);
return(NextStep.COMPLETED);
case "show":
if (cmd.arg1 != null)
{
Show(cmd.arg1.ToLower(), cmd.arg2);
}
else
{
cerr.WriteLine("invalid argument");
}
return(NextStep.COMPLETED);
case "find":
commandee.find(cmd, cmd.arg1);
return(NextStep.COMPLETED);
case "save":
commandee.save(cmd, cfg);
return(NextStep.COMPLETED);
case "execute":
commandee.execute(cmd, cfg, theSide);
if (commandee.ErrorCode == CommandState.OK)
{
return(NextStep.COMPLETED);
}
else
{
return(NextStep.ERROR);
}
case "open":
commandee.open(cmd, cfg);
return(NextStep.COMPLETED);
case "compare":
{
commandee.compare(cmd, cfg);
return(NextStep.COMPLETED);
}
case "copy":
commandee.copy(cmd, CompareSideType.copy);
return(NextStep.COMPLETED);
case "sync":
commandee.copy(cmd, CompareSideType.sync);
return(NextStep.COMPLETED);
case "comp":
commandee.copy(cmd, CompareSideType.compare);
return(NextStep.COMPLETED);
case "xcopy":
commandee.xcopy(cmd);
return(NextStep.COMPLETED);
case "lcd":
if (cmd.arg1 != null)
{
cfg.WorkingDirectory.ChangeDirectory(cmd.arg1);
}
else
{
cout.WriteLine(cfg.WorkingDirectory.CurrentDirectory);
}
return(NextStep.COMPLETED);
case "ldir":
cfg.WorkingDirectory.ShowCurrentDirectory(cmd.arg1);
return(NextStep.COMPLETED);
case "ltype":
if (cmd.arg1 != null)
{
string[] lines = cfg.WorkingDirectory.ReadAllLines(cmd.arg1);
if (lines != null)
{
foreach (var _line in lines)
{
cout.WriteLine(_line);
}
}
}
else
{
cout.WriteLine("invalid arguments");
}
return(NextStep.COMPLETED);
case "path":
if (cmd.arg1 == null)
{
cout.WriteLine(cfg.Path);
}
else
{
Context.SetValue("path", cmd.arg1);
}
return(NextStep.COMPLETED);
case "run":
if (cmd.arg1 != null)
{
new Batch(cfg, cmd.arg1).Call(this, cmd.Arguments);
}
return(NextStep.COMPLETED);
case "call":
if (!commandee.call(cmd))
{
return(NextStep.ERROR);
}
else
{
return(NextStep.COMPLETED);
}
case "import":
commandee.import(cmd, cfg, this);
return(NextStep.COMPLETED);
case "export":
commandee.export(cmd, cfg, this);
return(NextStep.COMPLETED);
case "load":
commandee.load(cmd, cfg, this);
return(NextStep.COMPLETED);
case "clean":
commandee.clean(cmd, cfg);
return(NextStep.COMPLETED);
case "mount":
commandee.mount(cmd, connection);
return(NextStep.COMPLETED);
case "umount":
commandee.umount(cmd, connection);
return(NextStep.COMPLETED);
case "edit":
commandee.edit(cmd, cfg, connection, theSide);
return(NextStep.COMPLETED);
case "last":
commandee.last(cmd, cfg);
return(NextStep.COMPLETED);
case "chk":
case "check":
commandee.check(cmd, theSide);
return(NextStep.COMPLETED);
default:
if (!_SQL.Contains(cmd.Action.ToUpper()))
{
cerr.WriteLine("invalid command");
return(NextStep.COMPLETED);
}
break;
}
return(NextStep.NEXT);
}
