public static TableName[] GetTableNames(ApplicationCommand cmd, PathManager mgr) { var pt = mgr.current; if (!(pt.Item is Locator) && !(pt.Item is TableName)) { if (cmd.arg1 != null) { PathName path = new PathName(cmd.arg1); var node = mgr.Navigate(path); if (node != null) { var dname = mgr.GetPathFrom <DatabaseName>(node); if (dname != null) { if (cmd.wildcard != null) { var m = new MatchedDatabase(dname, cmd); return(m.TableNames()); } else { var _tname = mgr.GetPathFrom <TableName>(node); if (_tname != null) { return new TableName[] { _tname } } ; else { cerr.WriteLine("invalid path"); return(null); } } } else { cerr.WriteLine("database is unavailable"); return(null); } } else { cerr.WriteLine("invalid path"); return(null); } } } if (pt.Item is TableName) { var tname = (TableName)pt.Item; return(new TableName[] { tname }); } return(null); }
private bool SetSource(string source, string sourceText) { if (source == null) { cerr.WriteLine("invalid argument"); return(false); } var path = new PathName(source); node = mgr.Navigate(path); if (node == null) { cerr.WriteLine("invalid path:" + path); return(false); } dname = mgr.GetPathFrom <DatabaseName>(node); if (dname == null) { cerr.WriteLine($"warning: {sourceText} database is unavailable"); return(false); } var server = mgr.GetPathFrom <ServerName>(node); side = new Side(dname); T = new TableName[] { }; if (path.wildcard != null) { var m1 = new MatchedDatabase(dname, path.wildcard) { Includedtables = cmd.Includes, Excludedtables = cmd.Excludes }; T = m1.TableNames(); } else { TableName tname = mgr.GetPathFrom <TableName>(node); if (tname == null) { T = dname.GetTableNames(); } else { T = new TableName[] { tname }; } } return(true); }
public void ExportData() { string directory = cmd.OutputDirectory(); if (directory != null) { xmlDbFile.XmlDbFolder = directory; } if (tname != null) { cout.WriteLine("start to generate {0} data file", tname); var dt = new TableReader(tname).Table; var file = xmlDbFile.WriteData(tname, dt); cout.WriteLine("completed {0} =>{1}", tname.ShortName, file); } else if (dname != null) { cout.WriteLine("start to generate {0}", dname); var mt = new MatchedDatabase(dname, cmd); CancelableWork.CanCancel(cts => { foreach (var tname in mt.TableNames()) { if (cts.IsCancellationRequested) { return; } cout.WriteLine("start to generate {0}", tname); var dt = new SqlBuilder().SELECT().TOP(cmd.Top).COLUMNS().FROM(tname).SqlCmd.FillDataTable(); var file = xmlDbFile.WriteData(tname, dt); cout.WriteLine("completed {0} => {1}", tname.ShortName, file); } return; } ); if (cmd.Top == 0) { cout.WriteLine("completed"); } else { cout.WriteLine("completed to export TOP {0} row(s) for each table", cmd.Top); } } else { cerr.WriteLine("warning: table or database is not seleted"); } }
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); }
public void ExportClass() { DpoOption option = new DpoOption { NameSpace = cfg.GetValue <string>(ConfigKey._GENERATOR_DPO_NS, "Sys.DataModel.Dpo"), OutputPath = cmd.OutputPath(ConfigKey._GENERATOR_DPO_PATH, $"{ConfigurationEnvironment.MyDocuments}\\DataModel\\Dpo"), Level = cfg.GetValue <Level>(ConfigKey._GENERATOR_DPO_LEVEL, Level.Application), HasProvider = cfg.GetValue <bool>(ConfigKey._GENERATOR_DPO_HASPROVIDER, false), HasTableAttribute = cfg.GetValue <bool>(ConfigKey._GENERATOR_DPO_HASTABLEATTR, true), HasColumnAttribute = cfg.GetValue <bool>(ConfigKey._GENERATOR_DPO_HASCOLUMNATTR, true), IsPack = cfg.GetValue <bool>(ConfigKey._GENERATOR_DPO_ISPACK, true), CodeSorted = cmd.Has("sort"), ClassNameSuffix = cfg.GetValue <string>(ConfigKey._GENERATOR_DPO_SUFFIX, Setting.DPO_CLASS_SUFFIX_CLASS_NAME) }; option.ClassNameRule = name => name.Substring(0, 1).ToUpper() + name.Substring(1).ToLower() + option.ClassNameSuffix; if (tname != null) { var clss = new DpoGenerator(tname) { Option = option }; clss.CreateClass(); cout.WriteLine("generated class {0} at {1}", tname.ShortName, option.OutputPath); } else if (dname != null) { cout.WriteLine("start to generate database {0} class to directory: {1}", dname, option.OutputPath); CancelableWork.CanCancel(cts => { var md = new MatchedDatabase(dname, cmd); TableName[] tnames = md.TableNames(); foreach (var tn in tnames) { if (cts.IsCancellationRequested) { return; } try { var clss = new DpoGenerator(tn) { Option = option }; clss.CreateClass(); cout.WriteLine("generated class for {0} at {1}", tn.ShortName, option.OutputPath); } catch (Exception ex) { cerr.WriteLine($"failed to generate class {tn.ShortName}, {ex.Message}"); } } cout.WriteLine("completed"); return; }); } else { cerr.WriteLine("warning: database is not selected"); } }
public void ExportCsvFile() { string path = this.cmd.OutputPath(ConfigKey._GENERATOR_CSV_PATH, $"{ConfigurationEnvironment.MyDocuments}\\csv"); string file; string fullName(TableName tname) => $"{path}\\{sname.Path}\\{dname.Name}\\{tname.ShortName}.csv"; if (tname != null) { cout.WriteLine("start to generate {0} csv file", tname); file = this.cmd.OutputFileName(); if (file == null) { file = fullName(tname); } var dt = new SqlBuilder().SELECT().COLUMNS(cmd.Columns).FROM(tname).SqlCmd.FillDataTable(); using (var writer = file.CreateStreamWriter(cmd.Append)) { CsvFile.Write(dt, writer, true); } cout.WriteLine("completed {0} => {1}", tname.ShortName, file); } else if (dname != null) { cout.WriteLine("start to generate {0} csv to directory: {1}", dname, path); CancelableWork.CanCancel(cts => { var md = new MatchedDatabase(dname, cmd); TableName[] tnames = md.TableNames(); foreach (var tn in tnames) { if (cts.IsCancellationRequested) { return; } try { file = fullName(tn); var dt = new TableReader(tn).Table; using (var writer = file.CreateStreamWriter(cmd.Append)) { CsvFile.Write(dt, writer, true); } cout.WriteLine("generated for {0} at {1}", tn.ShortName, path); } catch (Exception ex) { cerr.WriteLine($"failed to generate {tn.ShortName}, {ex.Message}"); } } cout.WriteLine("completed"); return; }); } else { cerr.WriteLine("warning: table or database is not seleted"); } }
public void ExportInsertOrUpdateData(SqlScriptType type) { var option = new SqlScriptGenerationOption { HasIfExists = cmd.HasIfExists, InsertWithoutColumns = cmd.Has("no-columns"), }; if (tname != null) { var node = mgr.GetCurrentNode <Locator>(); int count = 0; using (var writer = SqlFileName.CreateStreamWriter(cmd.Append)) { //cout.WriteLine($"start to generate {tname} script to file: \"{SqlFileName}\""); Locator locator = null; string WHERE = ""; if (node != null) { locator = mgr.GetCombinedLocator(node); WHERE = $" WHERE {locator}"; } long cnt = tname.GetTableRowCount(locator); count = Tools.ForceLongToInteger(cnt); using (var progress = new ProgressBar { Count = count }) { count = Compare.GenerateRows(type, writer, new TableSchema(tname), locator, option, progress); } cout.WriteLine($"{type} clauses (SELECT * FROM {tname}{WHERE}) generated to \"{SqlFileName}\", Done on rows({cnt})"); } } else if (dname != null) { //cout.WriteLine($"start to generate {dname} script to file: \"{SqlFileName}\""); using (var writer = SqlFileName.CreateStreamWriter(cmd.Append)) { var md = new MatchedDatabase(dname, cmd); TableName[] tnames = md.TableNames(); if (tnames.Length > 5 && !cin.YesOrNo($"Are you sure to export {tnames.Length} tables on {dname} (y/n)?")) { return; } CancelableWork.CanCancel(cts => { foreach (var tn in tnames) { if (cts.IsCancellationRequested) { return; } long cnt = tn.GetTableRowCount(); if (cnt > cfg.MaxRows) { if (!cin.YesOrNo($"Are you sure to export {cnt} rows on {tn.ShortName} (y/n)?")) { cout.WriteLine("\n{0,10} skipped", tn.ShortName); continue; } } int count = Tools.ForceLongToInteger(cnt); using (var progress = new ProgressBar { Count = count }) { count = Compare.GenerateRows(type, writer, new TableSchema(tn), null, option, progress); } cout.WriteLine($"{count,10} row(s) generated on {tn.ShortName}"); } cout.WriteLine($"completed to generate {type} clauses to \"{SqlFileName}\""); }); } } else { cerr.WriteLine("warning: table or database is not selected"); } }
public void del(Command cmd) { if (cmd.HasHelp) { stdio.WriteLine("command del or erase: drop tables or delete data rows"); stdio.WriteLine("del tablename : drop table"); stdio.WriteLine("del [sql where clause] : delete current table filtered rows"); stdio.WriteLine("example:"); stdio.WriteLine(@"local> del Northwind\Products : drop table [Products]"); stdio.WriteLine(@"local\Northwind\Products> del : delete all rows of table [Products]"); stdio.WriteLine(@"local\Northwind\Products> del col1=1 and col2='match' : del rows matched on columns:c1 or c2"); return; } var pt = mgr.current; if (!(pt.Item is Locator) && !(pt.Item is TableName)) { TableName[] T = null; if (cmd.arg1 != null) { PathName path = new PathName(cmd.arg1); var node = mgr.Navigate(path); if (node != null) { var dname = mgr.GetPathFrom<DatabaseName>(node); if (dname != null) { if (cmd.wildcard != null) { var m = new MatchedDatabase(dname, cmd.wildcard, new string[] { }); T = m.MatchedTableNames; } else { var _tname = mgr.GetPathFrom<TableName>(node); if (_tname != null) T = new TableName[] { _tname }; else { stdio.ErrorFormat("invalid path"); return; } } } else { stdio.ErrorFormat("database is unavailable"); return; } } else { stdio.ErrorFormat("invalid path"); return; } } if (T != null && T.Length > 0) { if (!stdio.YesOrNo("are you sure to drop {0} tables (y/n)?", T.Length)) return; try { var sqlcmd = new SqlCmd(T[0].Provider, string.Empty); sqlcmd.ExecuteNonQueryTransaction(T.Select(row => string.Format("DROP TABLE {0}", row))); stdio.ErrorFormat("completed to drop table(s):\n{0}", string.Join<TableName>("\n", T)); } catch (Exception ex) { stdio.ErrorFormat(ex.Message); } } else stdio.ErrorFormat("table is not selected"); return; } TableName tname = null; Locator locator = null; if (pt.Item is Locator) { locator = mgr.GetCombinedLocator(pt); tname = mgr.GetCurrentPath<TableName>(); if (!string.IsNullOrEmpty(cmd.args)) locator.And(new Locator(cmd.args)); } if (pt.Item is TableName) { tname = (TableName)pt.Item; if (!string.IsNullOrEmpty(cmd.args)) locator = new Locator(cmd.args); } if (locator == null) stdio.Write("are you sure to delete all rows (y/n)?"); else stdio.Write("are you sure to delete (y/n)?"); if (stdio.ReadKey() != ConsoleKey.Y) return; stdio.WriteLine(); try { int count; if (locator == null) count = new SqlBuilder().DELETE(tname).SqlCmd.ExecuteNonQuery(); else count = new SqlBuilder().DELETE(tname).WHERE(locator).SqlCmd.ExecuteNonQuery(); stdio.WriteLine("{0} of row(s) affected", count); } catch (Exception ex) { stdio.ErrorFormat(ex.Message); } }
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 void ExportCreate() { if (tname != null) { cout.WriteLine("start to generate CREATE TABLE script: {0}", dname); using (var writer = SqlFileName.CreateStreamWriter(cmd.Append)) { writer.WriteLine(tname.GenerateIfDropClause()); writer.WriteLine(tname.GenerateCreateTableClause(appendGO: true)); } cout.WriteLine("completed to generate script on file: {0}", SqlFileName); return; } if (dname != null) { if (cmd.wildcard != null) { var md = new MatchedDatabase(dname, cmd); TableName[] tnames = md.TableNames(); if (tnames.Length > 0) { Stack <string> stack = new Stack <string>(); Queue <string> queue = new Queue <string>(); foreach (var tname in tnames) { cout.WriteLine("start to generate CREATE TABLE script: {0} ", tname); stack.Push(tname.GenerateIfDropClause()); queue.Enqueue(tname.GenerateCreateTableClause(appendGO: true)); } using (var writer = SqlFileName.CreateStreamWriter(cmd.Append)) { while (stack.Count > 0) { writer.WriteLine(stack.Pop()); } while (queue.Count > 0) { writer.WriteLine(queue.Dequeue()); } } } else { cerr.WriteLine("warning: no table is matched"); return; } } else { cout.WriteLine("start to generate CREATE TABLE script: {0}", dname); using (var writer = SqlFileName.CreateStreamWriter(cmd.Append)) { writer.WriteLine(dname.GenerateClause()); } } cout.WriteLine("completed to generate script on file: {0}", SqlFileName); return; } cerr.WriteLine("warning: table or database is not seleted"); }
public void clean(Command cmd, Configuration cfg) { if (cmd.HasHelp) { stdio.WriteLine("clean duplicated rows"); stdio.WriteLine("clean [path]|[pattern]| : clean current database or table, or search pattern"); stdio.WriteLine("options:"); stdio.WriteLine(" /col:c1,c2,.. : clean columns, compare column c1, c2, ..."); stdio.WriteLine(" /d : commit cleaning duplicated rows on database server, otherwise display # of duplicated rows"); stdio.WriteLine("example:"); stdio.WriteLine("clean match*s /col:c1,c2 : clean duplicated rows by comparing columns:c1 and c2"); stdio.WriteLine("clean : clean by comparing entire row"); return; } if (!Navigate(cmd.Path1)) return; if (pt.Item is TableName) { var tname = (TableName)pt.Item; var dup = new DuplicatedTable(tname, cmd.Columns); if (cmd.Has("d")) { int count = dup.Clean(); stdio.WriteLine("completed to clean {0} #rows at {1}", count, tname); } else { int count = dup.DuplicatedRowCount(); if (count == 0) stdio.WriteLine("no duplicated rows at {0}", tname); else stdio.WriteLine("{0} duplicated row(s) at {1}", count, tname); } return; } if (pt.Item is DatabaseName) { var dname = (DatabaseName)pt.Item; var m = new MatchedDatabase(dname, cmd.wildcard, cfg.compareExcludedTables); var T = m.MatchedTableNames; CancelableWork.CanCancel(cts => { foreach (var tn in T) { if (cts.IsCancellationRequested) return; if (cmd.Has("d")) { stdio.WriteLine("start to clean {0}", tn); var dup = new DuplicatedTable(tn, cmd.Columns); int count = dup.Clean(); stdio.WriteLine("cleaned {0} #rows", count); } else { stdio.WriteLine("start to query {0}", tn); var dup = new DuplicatedTable(tn, cmd.Columns); int count = dup.DuplicatedRowCount(); if (count == 0) stdio.WriteLine("distinct rows"); else stdio.WriteLine("{0} duplicated row(s)", count, tn); } } }); return; } stdio.ErrorFormat("select database or table first"); }
public void ExportData(Command cmd) { if (tname != null) { stdio.WriteLine("start to generate {0} data file", tname); var dt = new TableReader(tname).Table; var file = xml.Write(tname, dt); stdio.WriteLine("completed {0} =>{1}", tname.ShortName, file); } else if (dname != null) { stdio.WriteLine("start to generate {0}", dname); var mt = new MatchedDatabase(dname, cmd.wildcard, cfg.exportExcludedTables); CancelableWork.CanCancel(cts => { foreach (var tname in mt.MatchedTableNames) { if (cts.IsCancellationRequested) return; stdio.WriteLine("start to generate {0}", tname); var dt = new SqlBuilder().SELECT.TOP(cmd.top).COLUMNS().FROM(tname).SqlCmd.FillDataTable(); var file = xml.Write(tname, dt); stdio.WriteLine("completed {0} => {1}", tname.ShortName, file); } return; } ); if (cmd.top == 0) stdio.WriteLine("completed"); else stdio.WriteLine("completed to export TOP {0} row(s) for each table", cmd.top); } else { stdio.ErrorFormat("warning: table or database is not seleted"); } }
public void ExportClass(Command cmd) { DpoOption option = new DpoOption(); option.NameSpace = cfg.GetValue<string>("dpo.ns", "Sys.DataModel.Dpo"); option.OutputPath = cfg.GetValue<string>("dpo.path", $"{Configuration.MyDocuments}\\DataModel\\Dpo"); option.Level = cfg.GetValue<Level>("dpo.level", Level.Application); option.HasProvider = cfg.GetValue<bool>("dpo.hasProvider", false); option.HasTableAttribute = cfg.GetValue<bool>("dpo.hasTableAttr", true); option.HasColumnAttribute = cfg.GetValue<bool>("dpo.hasColumnAttr", true); option.IsPack = cfg.GetValue<bool>("dpo.isPack", true); option.CodeSorted = cmd.Has("sort"); option.ClassNameSuffix = cfg.GetValue<string>("dpo.suffix", Setting.DPO_CLASS_SUFFIX_CLASS_NAME); option.ClassNameRule = name => name.Substring(0, 1).ToUpper() + name.Substring(1).ToLower() + option.ClassNameSuffix; if (tname != null) { var clss = new DpoGenerator(tname) { Option = option }; clss.CreateClass(); stdio.WriteLine("generated class {0} at {1}", tname.ShortName, option.OutputPath); } else if (dname != null) { stdio.WriteLine("start to generate database {0} class to directory: {1}", dname, option.OutputPath); CancelableWork.CanCancel(cts => { var md = new MatchedDatabase(dname, cmd.wildcard, cfg.exportExcludedTables); TableName[] tnames = md.MatchedTableNames; foreach (var tn in tnames) { if (cts.IsCancellationRequested) return; try { var clss = new DpoGenerator(tn) { Option = option }; clss.CreateClass(); stdio.WriteLine("generated class for {0} at {1}", tn.ShortName, option.OutputPath); } catch (Exception ex) { stdio.ErrorFormat("failed to generate class {0}, {1}", tn.ShortName, ex.Message); } } stdio.WriteLine("completed"); return; }); } else { stdio.ErrorFormat("warning: database is not selected"); } }
public void ExportDataSetXml() { if (dname == null) { cerr.WriteLine("select a database first"); return; } string path = cmd.OutputPath(ConfigKey._GENERATOR_DS_PATH, $"{ConfigurationEnvironment.MyDocuments}\\ds"); if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } if (tname != null) { cout.WriteLine($"start to generate data file: {tname}"); var dt = new TableReader(tname).Table; dt.TableName = tname.ShortName; string file = Path.Combine(path, $"{tname.ShortName}.xml"); DataSet ds = dt.DataSet; ds.DataSetName = dname.Name; ds.WriteXml(file, XmlWriteMode.WriteSchema); cout.WriteLine($"completed {tname} => {file}"); } else if (dname != null) { cout.WriteLine($"start to generate data file to directory: {dname}"); CancelableWork.CanCancel(cts => { var md = new MatchedDatabase(dname, cmd); //cfg.exportExcludedTables); TableName[] tnames = md.TableNames(); DataSet ds = new DataSet { DataSetName = dname.Name, }; foreach (var tn in tnames) { if (cts.IsCancellationRequested) { return; } try { var dt = new TableReader(tn).Table.Copy(); dt.TableName = tn.ShortName; ds.Tables.Add(dt); cout.WriteLine($"generated for {tn.ShortName}"); } catch (Exception ex) { cerr.WriteLine($"failed to generate {tn.ShortName}, {ex.Message}"); } } string file = Path.Combine(path, $"{dname.Name}.xml"); ds.WriteXml(file, XmlWriteMode.WriteSchema); cout.WriteLine($"completed generated: {file}"); return; }); } else { cerr.WriteLine("warning: table or database is not seleted"); } }
public void ExportLinq2SQLClass(Command cmd) { string path = cfg.GetValue<string>("l2s.path", $"{Configuration.MyDocuments}\\dc"); string ns = cmd.GetValue("ns") ?? cfg.GetValue<string>("l2s.ns", "Sys.DataModel.L2s"); Dictionary<TableName, TableSchema> schemas = new Dictionary<TableName, TableSchema>(); if (tname != null) { var builder = new Linq2SQLClassBuilder(ns, cmd, tname, schemas); string file = builder.WriteFile(path); stdio.WriteLine("code generated on {0}", file); } else if (dname != null) { TableName[] tnames; if (cmd.wildcard != null) { var md = new MatchedDatabase(dname, cmd.wildcard, new string[] { }); tnames = md.MatchedTableNames; if (tnames.Length == 0) { stdio.ErrorFormat("warning: no table is matched"); return; } } else { tnames = dname.GetTableNames(); } foreach (var tname in tnames) { var builder = new Linq2SQLClassBuilder(ns, cmd, tname, schemas); string file = builder.WriteFile(path); stdio.WriteLine("code generated on {0}", file); } return; } else { stdio.ErrorFormat("warning: table or database is not seleted"); } }
public void ExportInsert(Command cmd) { if (tname != null) { if (cmd.IsSchema) { using (var writer = fileName.NewStreamWriter()) { string sql = Compare.GenerateTemplate(new TableSchema(tname), SqlScriptType.INSERT); stdio.WriteLine(sql); writer.WriteLine(sql); } } else { var node = mgr.GetCurrentNode<Locator>(); int count; using (var writer = fileName.NewStreamWriter()) { if (node != null) { stdio.WriteLine("start to generate {0} INSERT script to file: {1}", tname, fileName); Locator locator = mgr.GetCombinedLocator(node); count = Compare.GenerateRows(writer, new TableSchema(tname), locator, cmd.HasIfExists); stdio.WriteLine("insert clauses (SELECT * FROM {0} WHERE {1}) generated to {2}", tname, locator, fileName); } else { count = Compare.GenerateRows(writer, new TableSchema(tname), null, cmd.HasIfExists); stdio.WriteLine("insert clauses (SELECT * FROM {0}) generated to {1}", tname, fileName); } } } } else if (dname != null) { stdio.WriteLine("start to generate {0} script to file: {1}", dname, fileName); using (var writer = fileName.NewStreamWriter()) { var md = new MatchedDatabase(dname, cmd.wildcard, cfg.exportExcludedTables); TableName[] tnames = md.MatchedTableNames; CancelableWork.CanCancel(cts => { foreach (var tn in tnames) { if (cts.IsCancellationRequested) return; if (!cfg.exportExcludedTables.IsMatch(tn.ShortName)) { int count = new SqlCmd(tn.Provider, string.Format("SELECT COUNT(*) FROM {0}", tn)).FillObject<int>(); if (count > cfg.Export_Max_Count) { if (!stdio.YesOrNo("are you sure to export {0} rows on {1} (y/n)?", count, tn.ShortName)) { stdio.WriteLine("\n{0,10} skipped", tn.ShortName); continue; } } count = Compare.GenerateRows(writer, new TableSchema(tn), null, cmd.HasIfExists); stdio.WriteLine("{0,10} row(s) generated on {1}", count, tn.ShortName); } else stdio.WriteLine("{0,10} skipped", tn.ShortName); } stdio.WriteLine("completed"); }); } } else stdio.ErrorFormat("warning: table or database is not selected"); }
public void ExportEntityClass(Command cmd) { if (dname == null) { stdio.ErrorFormat("select a database first"); return; } string path = cmd.GetValue("out") ?? cfg.GetValue<string>("dc.path", $"{Configuration.MyDocuments}\\dc"); string ns = cmd.GetValue("ns") ?? cfg.GetValue<string>("dc.ns", "Sys.DataModel.DataContracts"); if (tname != null) { stdio.WriteLine("start to generate {0} entity framework class file", tname); var builder = new EntityClassBuilder(ns, cmd, tname); string file = builder.WriteFile(path); stdio.WriteLine("completed {0} => {1}", tname.ShortName, file); } else if (dname != null) { stdio.WriteLine("start to generate {0} entity framework class to directory: {1}", dname, path); CancelableWork.CanCancel(cts => { var md = new MatchedDatabase(dname, cmd.wildcard, null); //cfg.exportExcludedTables); TableName[] tnames = md.MatchedTableNames; foreach (var tn in tnames) { if (cts.IsCancellationRequested) return; try { var builder = new EntityClassBuilder(ns, cmd, tn); string file = builder.WriteFile(path); stdio.WriteLine("generated for {0} at {1}", tn.ShortName, path); } catch (Exception ex) { stdio.ErrorFormat("failed to generate {0}, {1}", tn.ShortName, ex.Message); } } stdio.WriteLine("completed"); return; }); } else { stdio.ErrorFormat("warning: table or database is not seleted"); } }
public void ExportEntityClass() { if (dname == null) { cerr.WriteLine("select a database first"); return; } string path = cmd.OutputPath(ConfigKey._GENERATOR_DC_PATH, $"{ConfigurationEnvironment.MyDocuments}\\dc"); string ns = cmd.GetValue("ns", ConfigKey._GENERATOR_DC_NS, "Sys.DataModel.DataContracts"); if (tname != null) { cout.WriteLine("start to generate {0} entity framework class file", tname); var builder = new EntityClassBuilder(cmd, tname) { }; builder.SetNamespace(ns); if (!builder.IsAssocication) { string file = builder.WriteFile(path); cout.WriteLine("completed {0} => {1}", tname.ShortName, file); } } else if (dname != null) { cout.WriteLine("start to generate {0} entity framework class to directory: {1}", dname, path); CancelableWork.CanCancel(cts => { var md = new MatchedDatabase(dname, cmd); //cfg.exportExcludedTables); TableName[] tnames = md.TableNames(); foreach (var tn in tnames) { if (cts.IsCancellationRequested) { return; } try { var builder = new EntityClassBuilder(cmd, tn); builder.SetNamespace(ns); if (!builder.IsAssocication) { string file = builder.WriteFile(path); cout.WriteLine("generated for {0} at {1}", tn.ShortName, path); } } catch (Exception ex) { cerr.WriteLine($"failed to generate {tn.ShortName}, {ex.Message}"); } } cout.WriteLine("completed"); return; }); } else { cerr.WriteLine("warning: table or database is not seleted"); } }
public void ExportCreate(Command cmd) { if (tname != null) { stdio.WriteLine("start to generate CREATE TABLE script: {0}", dname); using (var writer = fileName.NewStreamWriter()) { writer.WriteLine(tname.GenerateCluase(true)); } stdio.WriteLine("completed to generate script on file: {0}", fileName); return; } if (dname != null) { if (cmd.wildcard != null) { var md = new MatchedDatabase(dname, cmd.wildcard, cfg.exportExcludedTables); TableName[] tnames = md.MatchedTableNames; if (tnames.Length > 0) { using (var writer = fileName.NewStreamWriter()) { foreach (var tname in tnames) { stdio.WriteLine("start to generate CREATE TABLE script: {0} ", tname); writer.WriteLine(tname.GenerateCluase(true)); } } } else { stdio.ErrorFormat("warning: no table is matched"); return; } } else { stdio.WriteLine("start to generate CREATE TABLE script: {0}", dname); using (var writer = fileName.NewStreamWriter()) { writer.WriteLine(dname.GenerateClause()); } } stdio.WriteLine("completed to generate script on file: {0}", fileName); return; } stdio.ErrorFormat("warning: table or database is not seleted"); }
private void Show(string arg1, string arg2) { var dname = theSide.DatabaseName; TableName[] vnames; switch (arg1) { case "pk": { var PKS = dname.TableWithPrimaryKey(); int count = 0; foreach (var tname in PKS) { count++; stdio.WriteLine("{0,5} {1}", $"[{count}]", tname); } stdio.WriteLine("total <{0}> tables with primary keys", count); } break; case "npk": { var tnames = dname.GetTableNames(); var PKS = dname.TableWithPrimaryKey(); int count = 0; foreach (var tname in tnames) { if (PKS.FirstOrDefault(row => row.Equals(tname)) == null) { count++; stdio.WriteLine("{0,5} {1}", $"[{count}]", tname); } } stdio.WriteLine("total <{0}> tables without primary keys", count); } break; case "vw": vnames = new MatchedDatabase(dname, arg2, null).DefaultViewNames; foreach (var vname in vnames) { DataTable dt = null; dt = vname.ViewSchema(); if (dt.Rows.Count > 0) { stdio.WriteLine("<{0}>", vname.ShortName); dt.ToConsole(); } else stdio.WriteLine("not found at <{0}>", vname.ShortName); } break; case "view": vnames = new MatchedDatabase(dname, arg2, null).DefaultViewNames; vnames.Select(tname => new { Schema = tname.SchemaName, View = tname.Name }) .ToConsole(); break; case "proc": dname.AllProc().ToConsole(); break; case "index": dname.AllIndices().ToConsole(); break; case "connection": { var list = cfg.GetValue("servers"); if (list.Defined) { list.Select(kvp => new { Alias = (string)kvp[0].HostValue, Connection = kvp[1].ToString() }) .ToConsole(); } else stdio.ErrorFormat("connection string not found"); } break; case "current": stdio.WriteLine("current: {0}({1})", theSide.Provider.Name, showConnection(theSide.Provider)); break; case "var": Context.ToConsole(); break; default: stdio.ErrorFormat("invalid argument"); break; } }
public void ExportCsvFile(Command cmd) { string path = cfg.GetValue<string>("csv.path", $"{Configuration.MyDocuments}\\csv"); string file; Func<TableName, string> fullName = tname => $"{path}\\{sname.Path}\\{dname.Name}\\{tname.ShortName}.csv"; if (tname != null) { stdio.WriteLine("start to generate {0} csv file", tname); file = fullName(tname); var dt = new SqlBuilder().SELECT.COLUMNS(cmd.Columns).FROM(tname).SqlCmd.FillDataTable(); using (var writer = file.NewStreamWriter()) { CsvFile.Write(dt, writer, true); } stdio.WriteLine("completed {0} => {1}", tname.ShortName, file); } else if (dname != null) { stdio.WriteLine("start to generate {0} csv to directory: {1}", dname, path); CancelableWork.CanCancel(cts => { var md = new MatchedDatabase(dname, cmd.wildcard, cfg.exportExcludedTables); TableName[] tnames = md.MatchedTableNames; foreach (var tn in tnames) { if (cts.IsCancellationRequested) return; try { file = fullName(tn); var dt = new TableReader(tn).Table; using (var writer = file.NewStreamWriter()) { CsvFile.Write(dt, writer, true); } stdio.WriteLine("generated for {0} at {1}", tn.ShortName, path); } catch (Exception ex) { stdio.ErrorFormat("failed to generate {0}, {1}", tn.ShortName, ex.Message); } } stdio.WriteLine("completed"); return; }); } else { stdio.ErrorFormat("warning: table or database is not seleted"); } }
private void Show(string arg1, string arg2) { var dname = theSide.DatabaseName; TableName[] vnames; switch (arg1) { case "pk": { var PKS = dname.TableWithPrimaryKey(); int count = 0; foreach (var tname in PKS) { count++; cout.WriteLine("{0,5} {1}", $"[{count}]", tname); } cout.WriteLine("total <{0}> tables with primary keys", count); } break; case "npk": { var tnames = dname.GetTableNames(); var PKS = dname.TableWithPrimaryKey(); int count = 0; foreach (var tname in tnames) { if (PKS.FirstOrDefault(row => row.Equals(tname)) == null) { count++; cout.WriteLine("{0,5} {1}", $"[{count}]", tname); } } cout.WriteLine("total <{0}> tables without primary keys", count); } break; case "vw": vnames = new MatchedDatabase(dname, arg2).ViewNames(); foreach (var vname in vnames) { DataTable dt = null; dt = vname.ViewSchema(); if (dt.Rows.Count > 0) { cout.WriteLine("<{0}>", vname.ShortName); dt.ToConsole(); } else { cout.WriteLine("not found at <{0}>", vname.ShortName); } } break; case "view": vnames = new MatchedDatabase(dname, arg2).ViewNames(); vnames.Select(tname => new { Schema = tname.SchemaName, View = tname.Name }) .ToConsole(); break; case "proc": dname.AllProc().ToConsole(); break; case "index": dname.AllIndices().ToConsole(); break; case "connection": { var L = connection.Providers.OrderBy(x => x.ServerName.Path); if (L.Count() > 0) { L.Select(pvd => new { Alias = pvd.ServerName.Path, Connection = pvd.ToSimpleString() }) .ToConsole(); } else { cerr.WriteLine("connection string not found"); } } break; case "current": cout.WriteLine("current: {0}({1})", theSide.Provider.Name, showConnection(theSide.Provider)); break; case "var": { ((VAL)Context.DS) .Where(row => row[1].VALTYPE != VALTYPE.nullcon && row[1].VALTYPE != VALTYPE.voidcon && !row[0].Str.StartsWith("$")) .Select(row => new { Variable = (string)row[0], Value = row[1] }) .ToConsole(); } break; default: cerr.WriteLine("invalid argument"); break; } }
private bool SetSource(string source, string sourceText) { if (source == null) { stdio.ErrorFormat("invalid argument"); return false; } var path = new PathName(source); node = mgr.Navigate(path); if (node == null) { stdio.ErrorFormat("invalid path:" + path); return false; } dname = mgr.GetPathFrom<DatabaseName>(node); if (dname == null) { stdio.ErrorFormat("warning: {0} database is unavailable", sourceText); return false; } var server = mgr.GetPathFrom<ServerName>(node); side = new Side(server.Provider, dname); T = new TableName[] { }; if (path.wildcard != null) { var m1 = new MatchedDatabase(dname, path.wildcard, mgr.Configuration.compareExcludedTables); T = m1.MatchedTableNames; } else { TableName tname = mgr.GetPathFrom<TableName>(node); if (tname == null) { T = dname.GetTableNames(); } else { T = new TableName[] { tname }; } } return true; }