public void SetValid (TableId tab, bool b)
{
long mask = 1L << (int) tab;
if (b) {
valid |= mask;
} else {
valid &= ~mask;
}
}
public override int GetHashCode()
{
int hash = 1;
if (Name.Length != 0)
{
hash ^= Name.GetHashCode();
}
if (TableId.Length != 0)
{
hash ^= TableId.GetHashCode();
}
if (table_ != null)
{
hash ^= Table.GetHashCode();
}
hash ^= initialSplitKeys_.GetHashCode();
return(hash);
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Tables
*---------------------------------------------------------------------------------------------------------------------------------*/
private questStatus create(MasterPricingEntities dbContext, Quest.Functional.MasterPricing.Table table, out TableId tableId)
{
// Initialize
questStatus status = null;
tableId = null;
// Perform create
try
{
Quest.Services.Dbio.MasterPricing.Tables _table = new Quest.Services.Dbio.MasterPricing.Tables();
BufferMgr.TransferBuffer(table, _table);
dbContext.Tables.Add(_table);
dbContext.SaveChanges();
if (_table.Id == 0)
{
return(new questStatus(Severity.Error, "Quest.Functional.MasterPricing.Table not created"));
}
tableId = new TableId(_table.Id);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors.SelectMany(x => x.ValidationErrors).Select(x => x.ErrorMessage);
String fullErrorMessage = string.Join("; ", errorMessages);
String exceptionMessage = string.Concat(ex.Message, fullErrorMessage);
status = new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
exceptionMessage));
LogException(ex, status);
return(status);
}
catch (System.Exception ex)
{
status = new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
ex.InnerException != null ? ex.InnerException.Message : ex.Message));
LogException(ex, status);
return(status);
}
return(new questStatus(Severity.Success));
}
private questStatus delete(MasterPricingEntities dbContext, TableId tableId)
{
// Initialize
questStatus status = null;
try
{
// Read the record.
Quest.Services.Dbio.MasterPricing.Tables _table = null;
status = read(dbContext, tableId, out _table);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Delete the record.
dbContext.Tables.Remove(_table);
dbContext.SaveChanges();
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors.SelectMany(x => x.ValidationErrors).Select(x => x.ErrorMessage);
String fullErrorMessage = string.Join("; ", errorMessages);
String exceptionMessage = string.Concat(ex.Message, fullErrorMessage);
status = new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
exceptionMessage));
LogException(ex, status);
return(status);
}
catch (System.Exception ex)
{
status = new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
ex.InnerException != null ? ex.InnerException.Message : ex.Message));
LogException(ex, status);
return(status);
}
status = new questStatus(Severity.Success, "Table successfully deleted. Table.Id=" + tableId.Id);
return(status);
}
public questStatus Read(DbMgrTransaction trans, TableId tableId, out Quest.Functional.MasterPricing.Table table)
{
// Initialize
questStatus status = null;
table = null;
// Perform read.
Quest.Services.Dbio.MasterPricing.Tables _table = null;
status = read((MasterPricingEntities)trans.DbContext, tableId, out _table);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
table = new Quest.Functional.MasterPricing.Table();
BufferMgr.TransferBuffer(_table, table);
return(new questStatus(Severity.Success));
}
public override string ToString()
{
var item = new StringBuilder();
item.Append("xact ");
item.Append($"{XactId.ToString()} ");
item.Append(TableId.ToString());
item.Append(" false ");
item.Append("Insert ");
item.Append("<data> ");
Data.ForEach(value =>
{
item.Append($"{value.Column.Name} ");
item.Append($"{value.Value} ");
});
item.Append(" </data>");
return(item.ToString());
}
/*==================================================================================================================================
* Properties
*=================================================================================================================================*/
#endregion
#region Public Methods
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus Create(Quest.Functional.MasterPricing.Table table, out TableId tableId)
{
// Initialize
questStatus status = null;
tableId = null;
// Data rules.
// Create the table
using (MasterPricingEntities dbContext = new MasterPricingEntities())
{
status = create(dbContext, table, out tableId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
return(new questStatus(Severity.Success));
}
/* Used or useful? */
public questStatus GetColumnInfo(TablesetColumn tablesetColumn, out Column column)
{
// Initialize
questStatus status = null;
column = null;
DbTablesetTablesMgr dbTablesetTablesMgr = new DbTablesetTablesMgr(this._userSession);
DbTablesetViewsMgr dbTablesetViewsMgr = new DbTablesetViewsMgr(this._userSession);
TablesetId tablesetId = null;
TablesetTable tablesetTable = null;
TablesetView tablesetView = null;
if (tablesetColumn.EntityTypeId == EntityType.Table)
{
// Get TablesetTable
TablesetTableId tablesetTableId = new TablesetTableId(tablesetColumn.TableSetEntityId);
status = dbTablesetTablesMgr.Read(tablesetTableId, out tablesetTable);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetId = new TablesetId(tablesetTable.TablesetId);
}
else if (tablesetColumn.EntityTypeId == EntityType.View)
{
// Get TablesetView
TablesetViewId tablesetViewId = new TablesetViewId(tablesetColumn.TableSetEntityId);
status = dbTablesetViewsMgr.Read(tablesetViewId, out tablesetView);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetId = new TablesetId(tablesetView.TablesetId);
}
else
{
return(new questStatus(Severity.Error, String.Format("ERROR: unsupported EntityTypeId {0} for TablesetColumn {1}",
tablesetColumn.EntityTypeId, tablesetColumn.Id)));
}
// Get the Tableset
DbTablesetsMgr dbTablesetsMgr = new DbTablesetsMgr(this._userSession);
Tableset tableset = null;
status = dbTablesetsMgr.Read(tablesetId, out tableset);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get the database
DatabaseId databaseId = new DatabaseId(tableset.DatabaseId);
Quest.Functional.MasterPricing.Database database = null;
DbDatabasesMgr dbDatabasesMgr = new DbDatabasesMgr(this._userSession);
status = dbDatabasesMgr.Read(databaseId, out database);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get the Table or View by identifier within this database
DbTablesMgr dbTablesMgr = new DbTablesMgr(this._userSession);
DbViewsMgr dbViewsMgr = new DbViewsMgr(this._userSession);
EntityTypeId entityTypeId = null;
EntityId entityId = null;
if (tablesetColumn.EntityTypeId == EntityType.Table)
{
TableId tableId = new TableId();
Table table = null;
status = dbTablesMgr.Read(databaseId, tablesetTable.Schema, tablesetTable.Name, out table);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
entityTypeId = new EntityTypeId(EntityType.Table);
entityId = new EntityId(table.Id);
}
else if (tablesetColumn.EntityTypeId == EntityType.View)
{
}
// Get column info
DbColumnsMgr dbColumnsMgr = new DbColumnsMgr(this._userSession);
status = dbColumnsMgr.Read(entityTypeId, entityId, tablesetColumn.Name, out column);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
//
// "Universal" accessors for Valid and Sorted bitvectors.
//
public bool IsValid (TableId tab)
{
return (valid & (1L << (int) tab)) != 0;
}
public FS.FilePath ApiRebasePath(Timestamp ts)
=> ContextRoot() + FS.file(string.Format("{0}.{1}", TableId.identify <ApiCatalogEntry>(), ts.Format()), FS.Csv);
public override string ToString()
{
var tableId = TableId < 0 ? "#V" : TableId.ToString();
return(String.Format("{0}-{1}", tableId, RowNumber));
}
protected MemberBase(AssemblyLoader loader, TableId table, int index)
{
Loader = loader;
MetadataToken = SimpleIndex.MakeToken(table, index + 1);
}
public static int MakeToken(TableId table, int index)
{
return((int)(((uint)table << 24) | (uint)index));
}
/// <summary>
/// 构造SQL字段
/// </summary>
/// <param name="propertyInfos">实体属性</param>
/// <returns></returns>
public string BuildSqlFiled <T>(PropertyInfo[] propertyInfos)
{
Type type = typeof(T);
string cacheKey = type.FullName + "_sqlFiled";
string idKey = type.FullName + "idType";
#region 缓存校验
if (StringCacheUntil.ExitsKey(cacheKey))
{
return(StringCacheUntil.GetCache(cacheKey));
}
#endregion
StringBuilder sqlFiled = new StringBuilder();
sqlFiled.Append("(");
int length = propertyInfos.Length - 1;
#region 拼接Sql
for (int i = 0; i <= length; i++)
{
PropertyInfo property = propertyInfos[i];
//判断字段是否是自增主键，如果是自增主键直接跳过
TableId tableId = property.GetCustomAttribute <TableId>();
if (tableId != null)
{
StringCacheUntil.AddCache(idKey, JsonConvert.SerializeObject(new KeyValuePair <string, IdTypeEnum>(property.Name, tableId._idType)));
if (tableId._idType == Enum.IdTypeEnum.AUTO)
{
continue;
}
}
TableFiled tableFiled = property.GetCustomAttribute <TableFiled>();
//最后一个字段不加,
if (i < length)
{
//如果不是数据库字段直接跳过
if (tableFiled != null)
{
if (!tableFiled.Exits)
{
continue;
}
sqlFiled.Append("`");
sqlFiled.Append(tableFiled.FiledName);
sqlFiled.Append("`");
sqlFiled.Append(",");
}
else
{
sqlFiled.Append("`");
sqlFiled.Append(property.Name);
sqlFiled.Append("`");
sqlFiled.Append(",");
}
}
else
{
//如果不是数据库字段直接跳过
if (tableFiled != null)
{
if (!tableFiled.Exits)
{
continue;
}
sqlFiled.Append("`");
sqlFiled.Append(tableFiled.FiledName);
sqlFiled.Append("`");
}
else
{
sqlFiled.Append("`");
sqlFiled.Append(property.Name);
sqlFiled.Append("`");
}
}
}
#endregion
sqlFiled.Append(")");
//加入缓存
string res = sqlFiled.ToString();
StringCacheUntil.AddCache(cacheKey, res);
return(res);
}
public JoinTable(ClientId clientId, TableId tableId)
{
this.clientId = clientId;
this.tableId = tableId;
}
public int GetRowCount(TableId id)
{
var table = GetTable(id);
return(table == null ? 0 : table.RowCount);
}
public MDTable this [TableId id] {
get {
return tables [id] as MDTable;
}
}
/// <summary>
/// Marks specified table in this heap as sorted or unsorted.
/// </summary>
/// <param name="tab"></param>
/// <param name="b"></param>
public void SetSorted (TableId tab, bool b)
{
long mask = 1L << (int) tab;
if (b) {
sorted |= mask;
} else {
sorted &= ~mask;
}
}
private IEnumerable <MetadataRow> GetRows(TableId tableId, IEnumerable <int> rows)
{
return(rows.Select(i => GetRow(tableId, i)));
}
internal int GetSimpleIndexSize(TableId id)
{
int n = GetRowCount(id);
return(SizeOfIndex(n));
}
public MDTable this [TableId id] {
get {
return(tables [id] as MDTable);
}
}
/// <summary>
/// True if the given table in this heap is sorted.
/// </summary>
/// <param name="tab"></param>
/// <returns></returns>
public bool IsSorted(TableId tab)
{
return((sorted & (1L << (int)tab)) != 0);
}
public questStatus Create(DbMgrTransaction trans, Quest.Functional.MasterPricing.Table table, out TableId tableId)
{
// Initialize
questStatus status = null;
tableId = null;
// Data rules.
// Create the table in this transaction.
status = create((MasterPricingEntities)trans.DbContext, table, out tableId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
internal static MetadataTable CreateTable(TableId id)
{
switch (id)
{
case TableId.Assembly: return(new MetadataTable(id, Assembly.Columns));
case TableId.AssemblyOS: return(new MetadataTable(id, AssemblyOS.Columns));
case TableId.AssemblyProcessor: return(new MetadataTable(id, AssemblyProcessor.Columns));
case TableId.AssemblyRef: return(new MetadataTable(id, AssemblyRef.Columns));
case TableId.AssemblyRefOS: return(new MetadataTable(id, AssemblyRefOS.Columns));
case TableId.AssemblyRefProcessor: return(new MetadataTable(id, AssemblyRefProcessor.Columns));
case TableId.ClassLayout: return(new MetadataTable(id, ClassLayout.Columns));
case TableId.Constant: return(new MetadataTable(id, Constant.Columns));
case TableId.CustomAttribute: return(new MetadataTable(id, CustomAttribute.Columns));
case TableId.DeclSecurity: return(new MetadataTable(id, DeclSecurity.Columns));
case TableId.EventMap: return(new MetadataTable(id, EventMap.Columns));
case TableId.Event: return(new MetadataTable(id, Event.Columns));
case TableId.ExportedType: return(new MetadataTable(id, ExportedType.Columns));
case TableId.Field: return(new MetadataTable(id, Field.Columns));
case TableId.FieldLayout: return(new MetadataTable(id, FieldLayout.Columns));
case TableId.FieldMarshal: return(new MetadataTable(id, FieldMarshal.Columns));
case TableId.FieldRVA: return(new MetadataTable(id, FieldRVA.Columns));
case TableId.File: return(new MetadataTable(id, File.Columns));
case TableId.GenericParam: return(new MetadataTable(id, GenericParam.Columns));
case TableId.GenericParamConstraint: return(new MetadataTable(id, GenericParamConstraint.Columns));
case TableId.ImplMap: return(new MetadataTable(id, ImplMap.Columns));
case TableId.InterfaceImpl: return(new MetadataTable(id, InterfaceImpl.Columns));
case TableId.ManifestResource: return(new MetadataTable(id, ManifestResource.Columns));
case TableId.MemberRef: return(new MetadataTable(id, MemberRef.Columns));
case TableId.MethodDef: return(new MetadataTable(id, MethodDef.Columns));
case TableId.MethodImpl: return(new MetadataTable(id, MethodImpl.Columns));
case TableId.MethodSemantics: return(new MetadataTable(id, MethodSemantics.Columns));
case TableId.MethodSpec: return(new MetadataTable(id, MethodSpec.Columns));
case TableId.Module: return(new MetadataTable(id, Module.Columns));
case TableId.ModuleRef: return(new MetadataTable(id, ModuleRef.Columns));
case TableId.NestedClass: return(new MetadataTable(id, NestedClass.Columns));
case TableId.Param: return(new MetadataTable(id, Param.Columns));
case TableId.Property: return(new MetadataTable(id, Property.Columns));
case TableId.PropertyMap: return(new MetadataTable(id, PropertyMap.Columns));
case TableId.StandAloneSig: return(new MetadataTable(id, StandAloneSig.Columns));
case TableId.TypeDef: return(new MetadataTable(id, TypeDef.Columns));
case TableId.TypeRef: return(new MetadataTable(id, TypeRef.Columns));
case TableId.TypeSpec: return(new MetadataTable(id, TypeSpec.Columns));
case TableId.FieldPtr: return(new MetadataTable(id, FieldPtr.Columns));
case TableId.MethodPtr: return(new MetadataTable(id, MethodPtr.Columns));
case TableId.ParamPtr: return(new MetadataTable(id, ParamPtr.Columns));
case TableId.EventPtr: return(new MetadataTable(id, EventPtr.Columns));
case TableId.PropertyPtr: return(new MetadataTable(id, PropertyPtr.Columns));
case TableId.EncodingLog: return(new MetadataTable(id, EncodingLog.Columns));
case TableId.EncodingMap: return(new MetadataTable(id, EncodingMap.Columns));
default: throw new ArgumentOutOfRangeException("id");
}
}
//
// "Universal" accessors for Valid and Sorted bitvectors.
//
public bool IsValid(TableId tab)
{
return((valid & (1L << (int)tab)) != 0);
}
/// <summary>
/// True if the given table in this heap is sorted.
/// </summary>
/// <param name="tab"></param>
/// <returns></returns>
public bool IsSorted (TableId tab)
{
return (sorted & (1L << (int) tab)) != 0;
}
/// <summary>
/// 根据id获取在excel中对应的sheet名
/// </summary>
/// <param name="tableId"></param>
/// <returns></returns>
private string getExcelSheetNameById(TableId tableId)
{
string name = ExcelDataAccess.getExcelSheetNameById(connectionString, (int)tableId);
return(name);
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
#region LIST
//----------------------------------------------------------------------------------------------------------------------------------
// LIST
//----------------------------------------------------------------------------------------------------------------------------------
public questStatus List(ColumnListViewModel viewModel, out ColumnListViewModel columnListViewModel)
{
// Initialize
questStatus status = null;
columnListViewModel = null;
// Read the database
DatabaseId databaseId = new DatabaseId(viewModel.DatabaseId);
DatabaseBaseViewModel databaseBaseViewModel = null;
DatabaseBaseModeler databaseBaseModeler = new DatabaseBaseModeler(this.HttpRequestBase, this.UserSession);
status = databaseBaseModeler.GetDatabase(databaseId, out databaseBaseViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get columns according to parent entity type
ColumnsMgr columnsMgr = new ColumnsMgr(this.UserSession);
List <Column> columnList = null;
Table table = null;
View view = null;
if (String.Equals(viewModel.ParentEntityType, "table", StringComparison.InvariantCultureIgnoreCase))
{
// Get table columns
TableId tableId = new TableId(viewModel.Id);
status = columnsMgr.Read(tableId, out columnList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Read the table info
TablesMgr tablesMgr = new TablesMgr(this.UserSession);
status = tablesMgr.Read(tableId, out table);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
else if (String.Equals(viewModel.ParentEntityType, "view", StringComparison.InvariantCultureIgnoreCase))
{
// Get view columns
ViewId viewId = new ViewId(viewModel.Id);
status = columnsMgr.Read(viewId, out columnList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Read the view info
ViewsMgr viewsMgr = new ViewsMgr(this.UserSession);
status = viewsMgr.Read(viewId, out view);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
else
{
return(new questStatus(Severity.Error, String.Format("Invalid ParentEntityType: {0}", viewModel.ParentEntityType)));
}
// Sort by display order
columnList.Sort(delegate(Column i1, Column i2) { return(i1.DisplayOrder.CompareTo(i2.DisplayOrder)); });
// Transfer model.
columnListViewModel = new ColumnListViewModel(this.UserSession, viewModel);
columnListViewModel.DatabaseId = databaseId.Id;
columnListViewModel.Database = databaseBaseViewModel;
columnListViewModel.Id = viewModel.Id;
columnListViewModel.ParentEntityType = viewModel.ParentEntityType;
if (table != null)
{
TableViewModel tableViewModel = new TableViewModel();
BufferMgr.TransferBuffer(table, tableViewModel);
columnListViewModel.Table = tableViewModel;
}
if (view != null)
{
ViewViewModel viewViewModel = new ViewViewModel();
BufferMgr.TransferBuffer(view, viewViewModel);
columnListViewModel.View = viewViewModel;
}
foreach (Column column in columnList)
{
ColumnLineItemViewModel columnLineItemViewModel = new ColumnLineItemViewModel();
BufferMgr.TransferBuffer(column, columnLineItemViewModel);
columnListViewModel.Items.Add(columnLineItemViewModel);
}
return(new questStatus(Severity.Success));
}
private static int GetIndexSize(TableId tab, int [] rows)
{
// Index is 2 bytes wide if table has less than 2^16 rows
// otherwise it's 4 bytes wide.
return ((uint) rows [(int) tab]) < (1 << 16) ? 2 : 4;
}
public SimpleIndex(TableId table, int index)
{
_value = ((uint)table << 24) | (uint)index;
}
