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); }