public SqlTable (ITableInfo tableInfo, JoinSemantics joinSemantics)
: base (tableInfo.ItemType, joinSemantics)
{
ArgumentUtility.CheckNotNull ("tableInfo", tableInfo);
_tableInfo = tableInfo;
}
private void Gen(StringBuilder sb, string tmp, ITableInfo tbInfo)
{
string code = codeGen.Gen(tmp, tbInfo);
bool sqlLine = false;
bool sqlBegin = false;
using (StringReader sr = new StringReader(code))
{
string line;
while ((line = sr.ReadLine()) != null)
{
if (line.IndexOf(" sql = ") > -1 && sqlBegin == false)
{
sqlBegin = true;
sqlLine = true;
sb.Append(" ");
}
if (!string.IsNullOrEmpty(line) && !sqlLine)
{
sb.Append(" ");
}
sb.Append(line);
sb.Append(Environment.NewLine);
if (sqlBegin && line.EndsWith("\";"))
{
sqlBegin = false;
sqlLine = false;
}
}//while
}//using
sb.AppendLine();
}
public string Build(ITableInfo tInfo, string ns, string webns, string modalName)
{
PageViewModel pvModel = new PageViewModel();
pvModel.NameSpacePR = ns;
pvModel.WebProjNameSpace = webns;
pvModel.DBTable = tInfo;
pvModel.DatabaseName = tInfo.Database.Name;
pvModel.ModalName = modalName;
_build("Model.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + ".cs");
_build("Map.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "Map.cs");
_build("Repository.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "Repository.cs");
_build("DTO.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "DTO.cs");
_build("IService.cshtml", typeof(PageViewModel), pvModel, "I" + tInfo.PascalName + "Service.cs");
_build("Service.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "Service.cs");
_build("Controller.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "Controller.cs");
_build("ViewModel.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "ViewModel.cs");
_build("Index.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "\\Index.cshtml");
_build("Add.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "\\Add.cshtml");
_build("Edit.cshtml", typeof(PageViewModel), pvModel, tInfo.PascalName + "\\Edit.cshtml");
_build("readme.cshtml", typeof(PageViewModel), pvModel, "readme.txt");
return this._targetFolder;
}
private void BindUI(IDatabaseInfo db)
{
this.Database = db;
this.SelectedChildTable = null;
this.SelectedParentTable = null;
this.cbForeignKey.Items.Clear();
this.cbForeignKey.Text = "";
this.gvFields.Rows.Clear();
cbTablesForChild.Items.Clear();
cbTablesForParent.Items.Clear();
cbTablesForChild.Text = "";
cbTablesForParent.Text = "";
if (db != null)
{
foreach (var table in db.Tables)
{
cbTablesForChild.Items.Add(table.Name);
cbTablesForParent.Items.Add(table.Name);
}
AspnetMVCSetting setting = SettingStore.Instance.Get<AspnetMVCSetting>(db.Name + "_aspnetmvc.xml");
if (setting != null)
{
txtNamespace.Text = setting.Namespace;
txtWebProjNameSpace.Text = setting.WebProjNameSpace;
}
}
}
public QueryTranslator(ITableInfo tableInfo)
{
_sb = new StringBuilder();
_limit = new StringBuilder();
_offset = new StringBuilder();
_orderBy = new StringBuilder();
_tableInfo = tableInfo;
}
public static ITableInfo ApplyContext (ITableInfo tableInfo, SqlExpressionContext expressionContext, IMappingResolutionStage stage, IMappingResolutionContext mappingResolutionContext)
{
ArgumentUtility.CheckNotNull ("tableInfo", tableInfo);
ArgumentUtility.CheckNotNull ("stage", stage);
ArgumentUtility.CheckNotNull ("mappingResolutionContext", mappingResolutionContext);
var visitor = new SqlContextTableInfoVisitor (stage, expressionContext, mappingResolutionContext);
return tableInfo.Accept (visitor);
}
public InsertInfo Create(ITableInfo tableInfo)
{
var columnsWillBeInsert = GetColumnsWillBeInsert(tableInfo);
return(new InsertInfo
{
Sql = GetSql(tableInfo, columnsWillBeInsert),
SqlParameters = columnsWillBeInsert
});
}
public static IResolvedTableInfo ResolveTableInfo (ITableInfo tableInfo, IMappingResolver resolver, UniqueIdentifierGenerator generator, IMappingResolutionStage stage, IMappingResolutionContext context)
{
ArgumentUtility.CheckNotNull ("tableInfo", tableInfo);
ArgumentUtility.CheckNotNull ("resolver", resolver);
ArgumentUtility.CheckNotNull ("stage", stage);
ArgumentUtility.CheckNotNull ("context", context);
var visitor = new ResolvingTableInfoVisitor (resolver, generator, stage, context);
return (IResolvedTableInfo) tableInfo.Accept (visitor);
}
public void Column_Names()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo employeeInfo = tableBuilder.GetConfig <Employee>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new string[] { "Id", "Name", "SurName" }, personInfo.ColumnNames);
Assert.Equal(new string[] { "Id", "Salary" }, employeeInfo.ColumnNames);
Assert.Equal(new string[] { "Id", "Name" }, deptInfo.ColumnNames);
}
public void Schema_Name()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo employeeInfo = tableBuilder.GetConfig <Employee>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Null(personInfo.Schema);
Assert.Null(employeeInfo.Schema);
Assert.Null(deptInfo.Schema);
}
public void Table_Name()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo employeeInfo = tableBuilder.GetConfig <Employee>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal("Person", personInfo.TableName);
Assert.Equal("Employee", employeeInfo.TableName);
Assert.Equal("Department", deptInfo.TableName);
}
public void Columns()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new string[] { "Guid", "Id", "Name", "SurName", "Employee.Address.Street", "Employee.Address.City",
"Employee.Salary", "Employee.DepartmentId", "Employee.Department.Guid", "Employee.Department.Id",
"Employee.Image" }, personInfo.Columns);
Assert.Equal(new string[] { "Guid", "Id", "Name", "Boss.Guid", "Boss.Id", "Tags" }, deptInfo.Columns);
}
public void Foreign_Keys()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo employeeInfo = tableBuilder.GetConfig <Employee>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new string[] { }, personInfo.ForeignKeys);
Assert.Equal(new string[] { "DepartmentId", "Department.Id" }, employeeInfo.ForeignKeys);
Assert.Equal(new string[] { "Boss.Id" }, deptInfo.ForeignKeys);
}
public void Primary_Keys()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo employeeInfo = tableBuilder.GetConfig <Employee>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new string[] { "Id" }, personInfo.PrimaryKeys);
Assert.Equal(new string[] { "Id" }, employeeInfo.PrimaryKeys);
Assert.Equal(new string[] { "Id" }, deptInfo.PrimaryKeys);
}
public void Column_Names()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new string[] { "Id", "Guid", "Name", "SurName", "EmployeeAddressStreet", "EmployeeAddressCity",
"EmployeeSalary", "EmployeeDepartmentId", "EmployeeDepartmentGuid", "EmployeeImage" },
personInfo.ColumnNames);
Assert.Equal(new string[] { "Id", "Guid", "Name", "BossGuid" }, deptInfo.ColumnNames);
}
public void Column_Names_Dic()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo employeeInfo = tableBuilder.GetConfig <Employee>();
ITableInfo bossInfo = tableBuilder.GetConfig <Boss>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new Dictionary <string, string>
{
["Id"] = "Id",
["Guid"] = "Guid",
["Name"] = "Name",
["SurName"] = "SurName",
["Address.Street"] = "AddressStreet",
["Address.City"] = "AddressCity"
}, personInfo.ColumnNamesDic);
Assert.Equal(new Dictionary <string, string>
{
["Id"] = "Id",
["Guid"] = "Guid",
["Name"] = "Name",
["SurName"] = "SurName",
["Address.Street"] = "AddressStreet",
["Address.City"] = "AddressCity",
["Salary"] = "Salary",
["DepartmentId"] = "DepartmentId",
["Department.Id"] = "DepartmentId",
["Image"] = "Image"
}, employeeInfo.ColumnNamesDic);
Assert.Equal(new Dictionary <string, string>
{
["Id"] = "Id",
["Guid"] = "Guid",
["Name"] = "Name",
["SurName"] = "SurName",
["Address.Street"] = "AddressStreet",
["Address.City"] = "AddressCity",
["Salary"] = "Salary",
["DepartmentId"] = "DepartmentId",
["Department.Id"] = "DepartmentId",
["Image"] = "Image",
["Bonus"] = "Bonus"
}, bossInfo.ColumnNamesDic);
Assert.Equal(new Dictionary <string, string>
{
["Id"] = "Id",
["Guid"] = "Guid",
["Name"] = "Name",
["Boss.Id"] = "BossId",
["Tags"] = "Tags"
}, deptInfo.ColumnNamesDic);
}
/// <summary>
/// 生成insert语句,
/// 计算列和自增列不插入
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public static string GetInsertSql(ITableInfo table)
{
StringBuilder sbSql = new StringBuilder();
sbSql.Append("\r\nINSERT INTO [");
sbSql.Append(table.Schema);
sbSql.Append("].[");
sbSql.Append(table.RawName);
sbSql.Append("]\r\n");
sbSql.Append(' ', 11);
sbSql.Append("(");
int len = table.Columns.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = table.Columns[i];
//计算列和自增列不插入
if (col.Identity || col.Computed)
continue;
sbSql.AppendFormat("[{0}]", col.RawName);
if (i != len - 1)
{
sbSql.Append("\r\n");
sbSql.Append(' ', 11);
sbSql.Append(",");
}
}
sbSql.Append(")\r\n");
sbSql.Append(' ', 5);
sbSql.Append("VALUES\r\n");
sbSql.Append(' ', 11);
sbSql.Append("(");
for (int i = 0; i < len; i++)
{
IColumnInfo col = table.Columns[i];
//计算列和自增列不插入
if (col.Identity || col.Computed)
continue;
sbSql.AppendFormat("@{0}", col.Name);
if (i != len - 1)
{
sbSql.Append("\r\n");
sbSql.Append(' ', 11);
sbSql.Append(",");
}
}
sbSql.Append(")\r\n");
return sbSql.ToString();
}
public void LoadTableNode(TreeNode node, ITableInfo obj)
{
node.Tag = obj;
node.Text = GetObjectName(obj);
node.ImageIndex = (int)TreeViewIcons.table;
node.SelectedImageIndex = (int)TreeViewIcons.table;
if (_showColumns)
{
AddColumns(node, obj.Columns);
}
}
/// <summary>
/// Compiles the fragment.
/// </summary>
/// <param name="queryBuilder">The query builder.</param>
/// <param name="engine">The engine.</param>
public virtual void Compile(QueryBuilder queryBuilder, IEngine engine)
{
ITableInfo tableInfo = engine.GetInfo(Type);
if (!string.IsNullOrEmpty(tableInfo.Schema))
{
queryBuilder.WriteName(tableInfo.Schema).Write(".");
}
queryBuilder.WriteName(tableInfo.TableName);
}
/// <inheritdoc/>
public void BreakLinkBetween(DataAccessCredentials credentials, ITableInfo tableInfo, DataAccessContext context)
{
_repository.Delete(
"DELETE FROM DataAccessCredentials_TableInfo WHERE DataAccessCredentials_ID = @cid AND TableInfo_ID = @tid and Context =@context",
new Dictionary <string, object>()
{
{ "cid", credentials.ID },
{ "tid", tableInfo.ID },
{ "context", context },
});
}
public void Reset_Type_Generic()
{
tableBuilder.Add <Person>()
.PrimaryKey(x => x.Guid);
tableBuilder.Reset <Person>();
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
Assert.Equal(new string[] { "Id" }, personInfo.PrimaryKeys);
}
public void Ignore_Delegate()
{
tableBuilder.AddProcessor(new DefaultMetadataProcessor()
.Ignore(x => x.EndsWith("2") || x.EndsWith("4") || x.EndsWith("6")));
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo employeeInfo = tableBuilder.GetConfig <Employee>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new Dictionary <string, IDictionary <string, object> >
{
["Id"] = new Dictionary <string, object>
{
["Id1"] = "Id1_Base",
["Id3"] = "Id3_Person",
["Id5"] = "Id5_Person"
},
["Address.Street"] = new Dictionary <string, object>
{
["AddressStreet1"] = "AddressStreet1_Person",
["AddressStreet3"] = "AddressStreet3_Person"
}
}, personInfo.MemberMetadata);
Assert.Equal(new Dictionary <string, IDictionary <string, object> >
{
["Id"] = new Dictionary <string, object>
{
["Id5"] = "Id5_Employee"
},
["Address.Street"] = new Dictionary <string, object>
{
["AddressStreet3"] = "AddressStreet3_Employee"
},
["Department"] = new Dictionary <string, object>
{
["Department1"] = "Department1_Employee"
}
}, employeeInfo.MemberMetadata);
Assert.Equal(new Dictionary <string, IDictionary <string, object> >
{
["Id"] = new Dictionary <string, object>
{
["Id1"] = "Id1_Base",
["Id3"] = "Id3_Department",
["Id5"] = "Id5_Department"
},
["Employees"] = new Dictionary <string, object>
{
["Employees1"] = "Employees1_Department"
}
}, deptInfo.MemberMetadata);
}
public void Reset_Type()
{
tableBuilder.Add(typeof(Person))
.PrimaryKey("Guid");
tableBuilder.Reset(typeof(Person));
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
Assert.Equal(new string[] { "Id" }, personInfo.PrimaryKeys);
}
protected override void MutilateTable(IDataLoadEventListener job, ITableInfo tableInfo, DiscoveredTable table)
{
var server = table.Database.Server;
job.OnNotify(this, new NotifyEventArgs(ProgressEventType.Information, "About to run Coalese on table " + table));
var allCols = table.DiscoverColumns();
var pkColumnInfos = tableInfo.ColumnInfos.Where(c => c.IsPrimaryKey).Select(c => c.GetRuntimeName()).ToArray();
var nonPks = allCols.Where(c => !pkColumnInfos.Contains(c.GetRuntimeName())).ToArray();
var pks = allCols.Except(nonPks).ToArray();
if (!pkColumnInfos.Any())
{
throw new Exception("Table '" + tableInfo + "' has no IsPrimaryKey columns");
}
if (allCols.Length == pkColumnInfos.Length)
{
job.OnNotify(this, new NotifyEventArgs(ProgressEventType.Warning, "Skipping Coalesce on table " + table + " because it has no non primary key columns"));
return;
}
int affectedRows = 0;
using (var con = table.Database.Server.GetConnection())
{
con.Open();
if (CreateIndex)
{
using (var idxCmd =
server.GetCommand(
string.Format(@"CREATE INDEX IX_PK_{0} ON {0}({1});", table.GetRuntimeName(),
string.Join(",", pks.Select(p => p.GetRuntimeName()))), con))
{
idxCmd.CommandTimeout = Timeout;
idxCmd.ExecuteNonQuery();
}
}
//Get an update command for each non primary key column
foreach (DiscoveredColumn nonPk in nonPks)
{
var sql = GetCommand(table, pks, nonPk);
var cmd = server.GetCommand(sql, con);
cmd.CommandTimeout = Timeout;
affectedRows += cmd.ExecuteNonQuery();
}
}
job.OnNotify(this, new NotifyEventArgs(ProgressEventType.Information, "Coalesce on table '" + table + "' completed (" + affectedRows + " rows affected)"));
}
public ViewTableInfoExtractUICollection(ITableInfo t, ViewType viewType, IFilter filter = null)
: this()
{
DatabaseObjects.Add(t);
if (filter != null)
{
DatabaseObjects.Add(filter);
}
ViewType = viewType;
}
public static IResolvedTableInfo ResolveTableInfo(ITableInfo tableInfo, IMappingResolver resolver, UniqueIdentifierGenerator generator, IMappingResolutionStage stage, IMappingResolutionContext context)
{
ArgumentUtility.CheckNotNull("tableInfo", tableInfo);
ArgumentUtility.CheckNotNull("resolver", resolver);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
var visitor = new ResolvingTableInfoVisitor(resolver, generator, stage, context);
return((IResolvedTableInfo)tableInfo.Accept(visitor));
}
public void Column_Names()
{
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo employeeInfo = tableBuilder.GetConfig <Employee>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new string[] { "Id2", "Guid", "Name2", "SurName", "Street2", "AddressCity" },
personInfo.ColumnNames);
Assert.Equal(new string[] { "Id2", "Salary2", "DepartmentId2", "Image2" }, employeeInfo.ColumnNames);
Assert.Equal(new string[] { "Id3", "Guid", "Name3", "BossId3" }, deptInfo.ColumnNames);
}
public void Nested_Recursive_Ignore()
{
tableBuilder.Add <Recursive.Person>()
.Ignore(x => x.Employee.Address1.Employee)
.Ignore(x => x.Employee.Address2.Employee);
ITableInfo propertyInfo = tableBuilder.GetConfig <Recursive.Person>();
Assert.Equal(new string[] { "Id", "Name", "Employee.Address1.Street", "Employee.Address2.Street",
"Employee.Salary" }, propertyInfo.Columns);
}
public static ContractCommentInfo Create(ITableInfo tableInfo)
{
var sb = new PaddedStringBuilder();
Write(sb, tableInfo);
return(new ContractCommentInfo
{
Comment = sb.ToString()
});
}
public ExecuteCommandSyncTableInfo(IBasicActivateItems activator,
[DemandsInitialization("The RDMP metadata object to synchronize with the underlying database state")]
ITableInfo table,
[DemandsInitialization("True to also synchronize any ANOTables (anonymisation tables) associated with the TableInfo")]
bool alsoSyncAno,
[DemandsInitialization("True to accept all changes without prompting")]
bool autoYes) : base(activator)
{
this._tableInfo = table;
this._alsoSyncAno = alsoSyncAno;
this._autoYes = autoYes;
}
/// <summary>
/// Creates a mock implementation of <see cref="ILoadMetadata"/> which loads the supplied <paramref name="tableInfo"/>
/// </summary>
/// <param name="tableInfo"></param>
/// <returns></returns>
public static ILoadMetadata Mock_LoadMetadataLoadingTable(ITableInfo tableInfo)
{
var lmd = new Mock <ILoadMetadata>();
var cata = new Mock <ICatalogue>();
lmd.Setup(m => m.GetDistinctLiveDatabaseServer()).Returns(tableInfo.Discover(DataAccessContext.DataLoad).Database.Server);
lmd.Setup(m => m.GetAllCatalogues()).Returns(new[] { cata.Object });
cata.Setup(m => m.GetTableInfoList(It.IsAny <bool>())).Returns(new[] { tableInfo });
return(lmd.Object);
}
/// <summary>
///
/// </summary>
/// <param name="n"></param>
/// <param name="t"></param>
public TableDTOTemplete(string n, ITableInfo t)
{
if (string.IsNullOrEmpty(n))
throw new Exception("参数n，命名空间不能为空。");
if (t == null)
throw new Exception("参数t，不能为null。");
this.NameSpace = n;
this.DBTable = t;
//this.DBTable.Refresh();
}
public void Disable_Attributes()
{
tableBuilder.Add <Attr.Person>();
tableBuilder.DisableAttributes();
ITableInfo personInfo = tableBuilder.GetConfig <Attr.Person>();
Assert.Equal("Person", personInfo.TableName);
Assert.Equal(new string[] { "Id" }, personInfo.PrimaryKeys);
Assert.Equal(new string[] { "Id", "Guid" }, personInfo.ColumnNames);
}
protected ICatalogue Import(DiscoveredTable tbl, out ITableInfo tableInfoCreated, out ColumnInfo[] columnInfosCreated, out CatalogueItem[] catalogueItems, out ExtractionInformation[] extractionInformations)
{
var importer = new TableInfoImporter(CatalogueRepository, tbl);
importer.DoImport(out tableInfoCreated, out columnInfosCreated);
var forwardEngineer = new ForwardEngineerCatalogue(tableInfoCreated, columnInfosCreated, true);
forwardEngineer.ExecuteForwardEngineering(out var catalogue, out catalogueItems, out extractionInformations);
return(catalogue);
}
public static ParameterValidationResult ArePrimaryKeysValid(ITableInfo tableInfo, List <string> constantColumns, List <string> scrambledColumns)
{
try
{
CheckParams(tableInfo, constantColumns, scrambledColumns, Resources.Check_Primary_keys);
return(new ParameterValidationResult(true, tableInfo.FullTableName, ""));
}
catch (Exception ex)
{
return(new ParameterValidationResult(false, tableInfo.FullTableName, ex.Message));
}
}
static IReadOnlyList <IColumnInfo> GetColumnsWillBeUpdate(ITableInfo tableInfo)
{
var excludedColumnNames = tableInfo.PrimaryKeyColumns.Select(x => x.ColumnName).ToList();
excludedColumnNames.Add(Names2.INSERT_DATE);
excludedColumnNames.Add(Names2.INSERT_TOKEN_ID);
excludedColumnNames.Add(Names2.INSERT_USER_ID);
excludedColumnNames.Add(Names2.ROW_GUID);
excludedColumnNames.Add(Names2.INSERT_USER_ID);
return(tableInfo.Columns.Where(c => !excludedColumnNames.Contains(c.ColumnName)).ToList());
}
public void Add_Type_Delegate()
{
tableBuilder.Add(typeof(Person), config => config
.PrimaryKey("Guid"))
.Add(typeof(Department), config => config
.PrimaryKey("Guid"));
ITableInfo personInfo = tableBuilder.GetConfig <Person>();
ITableInfo deptInfo = tableBuilder.GetConfig <Department>();
Assert.Equal(new string[] { "Guid" }, personInfo.PrimaryKeys);
Assert.Equal(new string[] { "Guid" }, deptInfo.PrimaryKeys);
}
public override void setup( string connectionString, ITableInfo tableInfo )
{
// If we're using file backing, then the connection string will start with "file=".
if( connectionString.StartsWith( "path=" ) )
{
_filepath = connectionString.Substring( "file=".Length );
if( !Directory.Exists( _filepath ) )
Directory.CreateDirectory( _filepath );
loadAll();
}
else
throw new ArgumentException( "Connection string does not start with 'path='" );
}
/// <summary>
/// Deletes any rows in tiCurrent that are out-of-date (with respect to live) and childless, then updates remaining out-of-date rows with the values from staging.
/// Out-of-date remaining rows will only be present if they have children which are to be inserted. Any other children will have been deleted in an earlier pass through the recursion (since it starts at the leaves and works upwards).
/// </summary>
/// <param name="tiCurrent"></param>
/// <param name="joinPathToTimeTable">Chain of JoinInfos back to the TimePeriodicity table so we can join to it and recover the effective date of a particular row</param>
/// <param name="childJoins"></param>
private void ProcessTable(ITableInfo tiCurrent, List <JoinInfo> joinPathToTimeTable, List <JoinInfo> childJoins)
{
var columnSetsToMigrate = _migrationConfiguration.CreateMigrationColumnSetFromTableInfos(new[] { tiCurrent }.ToList(), null, new BackfillMigrationFieldProcessor());
var columnSet = columnSetsToMigrate.Single();
var queryHelper = new ReverseMigrationQueryHelper(columnSet);
var mcsQueryHelper = new MigrationColumnSetQueryHelper(columnSet);
// Any DELETEs needed?
DeleteEntriesHavingNoChildren(tiCurrent, joinPathToTimeTable, childJoins, mcsQueryHelper);
// Update any out-of-date rows that have survived the delete, so they don't overwrite live with stale data. They will only survive the delete if they have children due for insertion into live.
UpdateOldParentsThatHaveNewChildren(tiCurrent, joinPathToTimeTable, queryHelper, mcsQueryHelper);
}
/// <summary>
///
/// </summary>
/// <param name="n"></param>
/// <param name="t"></param>
public TableDocTemplete(ITableInfo t)
{
if (t == null)
throw new Exception("参数t，不能为null。");
this.DBTable = t;
this.TableName = this.DBTable.RawName;
//this.DBTable.Refresh();
}
private void Add(PreLoadDiscardedColumn discardedColumn, ITableInfo tableInfo, string rawDbName)
{
var snip = new SubstringAutocompleteItem(discardedColumn.GetRuntimeName());
var colName = discardedColumn.GetRuntimeName();
snip.MenuText = colName;
snip.Text = tableInfo.GetQuerySyntaxHelper().EnsureFullyQualified(rawDbName, null, tableInfo.GetRuntimeName(), colName);
snip.Tag = discardedColumn;
snip.ImageIndex = GetIndexFor(discardedColumn, RDMPConcept.ColumnInfo.ToString());
AddUnlessDuplicate(snip);
}
public Module(ITableInfo tbInfo)
{
this.CodeName = tbInfo.PascalName;
var fields = new List<ModuleField>();
foreach (var col in tbInfo.Columns)
{
ModuleField field = new ModuleField(this, col.Description, col.RawName, col.PascalName);
field.LanguageType = col.LanguageType;
field.Nullable = col.Nullable;
if(col.MaxLength.HasValue && col.MaxLength > 0)
{
field.StringLength = col.MaxLength.Value;
}
fields.Add(field);
}
this.Fields = fields;
}
//private readonly string Temp_Table_Model = Comm.GetTemplete("Table.Model.cshtml");
//private readonly string Temp_Table_Insert = Comm.GetTemplete("Table.Insert.cshtml");
//private readonly string Temp_Table_Update = Comm.GetTemplete("Table.Update.cshtml");
//private readonly string Temp_Table_Delete = Comm.GetTemplete("Table.Delete.cshtml");
//private readonly string Temp_Table_Save = Comm.GetTemplete("Table.Save.cshtml");
//private readonly string Temp_Table_Exist = Comm.GetTemplete("Table.Exist.cshtml");
//private readonly string Temp_Table_Get = Comm.GetTemplete("Table.Get.cshtml");
//private readonly string Temp_Table_GetAll = Comm.GetTemplete("Table.GetAll.cshtml");
//private readonly string Temp_Table_Top = Comm.GetTemplete("Table.Top.cshtml");
//private readonly string Temp_Table_Paged = Comm.GetTemplete("Table.Paged.cshtml");
//private readonly string Temp_Table_GetBytes = Comm.GetTemplete("_GetBytes.cshtml");
//private readonly string Temp_Table_GetMany = Comm.GetTemplete("Table._GetMany.cshtml");
public string GenDataAccessCode(string nameSpace, ITableInfo tbInfo)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("using System;");
sb.AppendLine("using System.Collections.Generic;");
sb.AppendLine("using System.Data;");
sb.AppendLine("using System.Data.SqlClient;");
sb.AppendLine("using System.Linq;");
sb.AppendLine("using System.Text;");
sb.AppendFormat("using {0};{1}", nameSpace, Environment.NewLine);
sb.AppendFormat("using {0}.Model;{1}", nameSpace, Environment.NewLine);
sb.AppendLine();
sb.AppendFormat("namespace {0}.DAL{1}", nameSpace, Environment.NewLine);
sb.AppendLine("{");
sb.AppendFormat(" public class {0}Access{1}", tbInfo.PascalName, Environment.NewLine);
sb.AppendLine(" {");
Gen(sb, Comm.GetTemplete("Table.Insert.cshtml"), tbInfo);
Gen(sb, Comm.GetTemplete("Table.Update.cshtml"), tbInfo);
Gen(sb, Comm.GetTemplete("Table.Delete.cshtml"), tbInfo);
//Gen(sb, Comm.GetTemplete("Table.Save.cshtml"), tbInfo);
//Gen(sb, Comm.GetTemplete("Table.Exist.cshtml"), tbInfo);
Gen(sb, Comm.GetTemplete("Table.Get.cshtml"), tbInfo);
//Gen(sb, Comm.GetTemplete("Table.Top.cshtml"), tbInfo);
Gen(sb, Comm.GetTemplete("Table.GetAll.cshtml"), tbInfo);
Gen(sb, Comm.GetTemplete("Table.Paged.cshtml"), tbInfo);
if ((from col in tbInfo.Columns
where col.DbTargetType == "SqlDbType.Image" || col.DbTargetType == "SqlDbType.Binary"
|| col.DbTargetType == "SqlDbType.VarBinary" || col.DbTargetType == "SqlDbType.Timestamp"
select col).Count() > 0)
{
Gen(sb, Comm.GetTemplete("_GetBytes.cshtml"), tbInfo);
}
Gen(sb, Comm.GetTemplete("Table._GetMany.cshtml"), tbInfo);
sb.AppendLine(" }");
sb.AppendLine("}");
return sb.ToString();
}
/// <summary>
/// 未使用
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public static string GetUpdateByPKSql(ITableInfo table)
{
StringBuilder sbSql = new StringBuilder();
sbSql.Append("\r\nUPDATE [");
sbSql.Append(table.Schema);
sbSql.Append("].[");
sbSql.Append(table.Name);
sbSql.Append("]\r\n");
sbSql.Append(' ', 3);
sbSql.Append("SET ");
int len = table.Columns.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = table.Columns[i];
if (col.Identity || col.Computed || col.IsPrimaryKey)
continue;
sbSql.AppendFormat("[{0}] = @{1}", col.Name, SetPascalCase(col.Name));
if (i != len - 1)
{
sbSql.Append("\r\n");
sbSql.Append(' ', 6);
sbSql.Append(",");
}
}
sbSql.Append("\r\n");
sbSql.Append(" WHERE ");
List<IColumnInfo> pks = GetPKs(table);
len = pks.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = pks[i];
sbSql.AppendFormat("[{0}] = @{1}", col.Name, SetPascalCase(col.Name));
if (i != len - 1)
{
sbSql.Append(" AND ");
}
}
sbSql.Append("\r\n");
return sbSql.ToString();
}
public string GetByIdString(ITableInfo tinfo, string p1, string p2)
{
StringBuilder sb = new StringBuilder();
foreach (var col in tinfo.Columns)
{
if (!col.IsPrimaryKey)
{
continue;
}
if (sb.Length > 0)
{
sb.Append(" && ");
}
sb.AppendFormat("{0}.{2} == {1}.{2}", p1, p2, col.PascalName);
}
return sb.ToString();
}
public string GetUpdateFilterString(ITableInfo tinfo, string modelName)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < tinfo.Keys.Count; i++)
{
if (i > 0)
{
sb.Append(" && ");
}
var item = tinfo.Keys[i];
sb.AppendFormat("p.{0} == {1}.{0}", item.PascalName, modelName);
}
return sb.ToString();
}
public virtual void setup( string connectionString, ITableInfo tableInfo )
{
// Always succeeds. We're not connecting to anything. We also don't need tableInfo.
}
public StoreConventions(IJsonConverter jsonConverter, ITableInfo tableInfo)
{
_jsonConverter = jsonConverter;
_tableInfo = tableInfo;
}
public StoreConventions(IJsonConverter jsonConverter)
{
_jsonConverter = jsonConverter;
_tableInfo = new TableInfo();
}
public static string GetColumnString(ITableInfo table)
{
StringBuilder sbSql = new StringBuilder();
//sbSql.Append("\r\nSELECT ");// [");
int len = table.Columns.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = table.Columns[i];
//if (col.InPrimaryKey)
// continue;
sbSql.AppendFormat("[{0}]", col.RawName);
if (i != len - 1)
{
//sbSql.Append("\r\n");
//sbSql.Append(' ', 6);
sbSql.Append(", ");
}
}
//sbSql.Append("\r\n");
//sbSql.Append(' ', 2);
//sbSql.Append("FROM [");
//sbSql.Append(table.Schema);
//sbSql.Append("].[");
//sbSql.Append(table.RawName);
//sbSql.Append("]\r\n");
return sbSql.ToString();
}
public static SqlTable CreateSqlTable (ITableInfo tableInfo)
{
var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner);
return sqlTable;
}
/// <summary>
/// if(item.Key == "Feature" || item.Key == "Feature2") continue;
/// 计算列，自增列，主键列
/// </summary>
/// <returns></returns>
public static string BuildGetKeyEqContinue(ITableInfo table)
{
string result = "";
int len = table.Columns.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = table.Columns[i];
if (col.IsPrimaryKey || col.Computed || col.Identity)
{
if (result != "")
{
result += " || ";
}
result += "item.Key == \"" + col.RawName + "\"";
}
}
if (result != "")
{
result = string.Format("if({0}) continue;", result);
}
return result;
}
//public static string GetPKName(Table table)
//{
// List<Column> result = new List<Column>();
// int len = table.Columns.Count;
// for (int i = 0; i < len; i++)
// {
// Column col = table.Columns[i];
// if (col.InPrimaryKey)
// return col.Name;
// }
// return "";
//}
public static string GetDefaultOrderby(ITableInfo table)
{
StringBuilder sbSql = new StringBuilder();
List<IColumnInfo> pks = GetPKs(table);
int len = pks.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = pks[i];
sbSql.AppendFormat("{0} asc", col.RawName);
if (i != len - 1)
{
sbSql.Append(", ");
}
}
return sbSql.ToString();
}
public static string GetExistByPKSql(ITableInfo table)
{
StringBuilder sbSql = new StringBuilder();
sbSql.Append("\r\nSELECT COUNT(*) FROM [");
sbSql.Append(table.Schema);
sbSql.Append("].[");
sbSql.Append(table.RawName);
sbSql.Append("]\r\n");
sbSql.Append(' ', 6);
sbSql.Append("WHERE ");
List<IColumnInfo> pks = GetPKs(table);
int len = pks.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = pks[i];
sbSql.AppendFormat("[{0}] = @{1}", col.RawName, col.Name);
if (i != len - 1)
{
sbSql.Append(" AND ");
}
}
sbSql.Append("\r\n");
return sbSql.ToString();
}
public static string GetPKValueString(ITableInfo table)
{
StringBuilder sbSql = new StringBuilder();
List<IColumnInfo> pks = GetPKs(table);
int len = pks.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = pks[i];
sbSql.AppendFormat("this.{0}", col.PascalName);
if (i != len - 1)
{
sbSql.Append(", ");
}
}
return sbSql.ToString();
}
public static string BuildGetByPKSql(ITableInfo table)
{
StringBuilder sbSql = new StringBuilder();
sbSql.Append("\r\nSELECT ");// [");
int len = table.Columns.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = table.Columns[i];
//if (col.InPrimaryKey)
// continue;
sbSql.AppendFormat("[{0}]", col.RawName);
if (i != len - 1)
{
sbSql.Append("\r\n");
sbSql.Append(' ', 6);
sbSql.Append(",");
}
}
sbSql.Append("\r\n");
sbSql.Append(' ', 2);
sbSql.Append("FROM [");
sbSql.Append(table.Schema);
sbSql.Append("].[");
sbSql.Append(table.RawName);
sbSql.Append("]\r\n");
sbSql.Append(" WHERE ");
List<IColumnInfo> pks = GetPKs(table);
len = pks.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = pks[i];
sbSql.AppendFormat("[{0}] = @{1}", col.RawName, col.Name);
if (i != len - 1)
{
sbSql.Append(" AND ");
}
}
sbSql.Append("\r\n");
return sbSql.ToString();
}
public StoreConventions()
{
_jsonConverter = new JilJsonConverter();
_tableInfo = new TableInfo();
}
public static string GetPKDefine(ITableInfo table)
{
StringBuilder sbSql = new StringBuilder();
List<IColumnInfo> pks = GetPKs(table);
int len = pks.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = pks[i];
sbSql.AppendFormat("{0} {1}", col.LanguageType, col.CamelName);
if (i != len - 1)
{
sbSql.Append(", ");
}
}
return sbSql.ToString();
}
public static List<IColumnInfo> GetPKs(ITableInfo table)
{
List<IColumnInfo> result = new List<IColumnInfo>();
int len = table.Columns.Count;
for (int i = 0; i < len; i++)
{
IColumnInfo col = table.Columns[i];
if (col.IsPrimaryKey)
result.Add(col);
}
return result;
}
public PageFormModel(ITableInfo tbInfo)
{
this.FormModule = new Module(tbInfo);
}