public override ProjectionExpression GetQueryExpression(MappingEntity entity)
{
var tables = this.mapping.GetTables(entity);
if (tables.Count <= 1)
{
return(base.GetQueryExpression(entity));
}
var aliases = new Dictionary <string, TableAlias>();
MappingTable rootTable = tables.Single(ta => !this.mapping.IsExtensionTable(ta));
var tex = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(rootTable));
aliases.Add(this.mapping.GetAlias(rootTable), tex.Alias);
Expression source = tex;
foreach (MappingTable table in tables.Where(t => this.mapping.IsExtensionTable(t)))
{
TableAlias joinedTableAlias = new TableAlias();
string extensionAlias = this.mapping.GetAlias(table);
aliases.Add(extensionAlias, joinedTableAlias);
List <string> keyColumns = this.mapping.GetExtensionKeyColumnNames(table).ToList();
List <MemberInfo> relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToList();
string relatedAlias = this.mapping.GetExtensionRelatedAlias(table);
TableAlias relatedTableAlias;
aliases.TryGetValue(relatedAlias, out relatedTableAlias);
TableExpression joinedTex = new TableExpression(joinedTableAlias, entity, this.mapping.GetTableName(table));
Expression cond = null;
for (int i = 0, n = keyColumns.Count; i < n; i++)
{
var memberType = TypeHelper.GetMemberType(relatedMembers[i]);
var colType = this.GetColumnType(entity, relatedMembers[i]);
var relatedColumn = new ColumnExpression(memberType, colType, relatedTableAlias, this.mapping.GetColumnName(entity, relatedMembers[i]));
var joinedColumn = new ColumnExpression(memberType, colType, joinedTableAlias, keyColumns[i]);
var eq = joinedColumn.Equal(relatedColumn);
cond = (cond != null) ? cond.And(eq) : eq;
}
source = new JoinExpression(JoinType.SingletonLeftOuter, source, joinedTex, cond);
}
var columns = new List <ColumnDeclaration>();
this.GetColumns(entity, aliases, columns);
SelectExpression root = new SelectExpression(new TableAlias(), columns, source, null);
var existingAliases = aliases.Values.ToArray();
Expression projector = this.GetEntityExpression(root, entity);
var selectAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.Translator.Linguist.Language, projector, null, selectAlias, root.Alias);
var proj = new ProjectionExpression(
new SelectExpression(selectAlias, pc.Columns, root, null),
pc.Projector);
return((ProjectionExpression)this.Translator.Police.ApplyPolicy(proj, entity.ElementType));
}
protected void btnDelete_Click(object sender, EventArgs e)
{
try
{
labelMessage.Text = string.Empty;
using (MappingTableRT receiverTransfer = new MappingTableRT())
{
hdIsDelete.Value = "true";
hdIsEdit.Value = "true";
MappingTable mapping = CreateMappingTable();
if (mapping != null)
{
receiverTransfer.UpdateMappingTable(mapping);
labelMessage.Text = "Data successfully deleted...";
labelMessage.ForeColor = System.Drawing.Color.Green;
}
else
{
labelMessage.Text = "Data not deleted...";
labelMessage.ForeColor = System.Drawing.Color.Red;
}
}
LoadMappingTable();
ClearField();
}
catch (Exception ex)
{
labelMessage.Text = "Error : " + ex.Message;
labelMessage.ForeColor = System.Drawing.Color.Red;
}
SetButton();
}
//For Edit Mapping
protected void lvMapping_ItemCommand(object sender, ListViewCommandEventArgs e)
{
if (e.CommandName == "EditMapping")
{
try
{
labelMessage.Text = string.Empty;
btnSave.Visible = false;
btnUpdate.Visible = true;
btnDelete.Visible = true;
btnCancel.Visible = true;
int mappingID = Convert.ToInt32(e.CommandArgument);
hdMappingID.Value = mappingID.ToString();
using (MappingTableRT receiverTransfer = new MappingTableRT())
{
MappingTable mapping = receiverTransfer.GetMappingByIID(mappingID);
FillMappingTableForEdit(mapping);
}
}
catch (Exception ex)
{
labelMessage.Text = "Error : " + ex.Message;
labelMessage.ForeColor = System.Drawing.Color.Red;
}
}
}
/// <summary>
/// Create Nodeprep profile
/// </summary>
/// <returns>Nodeprep process</returns>
public static IPreparationProcess Create()
{
return(PreparationProcess.Build()
.WithMappingStep(MappingTable.Build()
.WithMappingTable(Mapping.B_1)
.WithMappingTable(Mapping.B_2)
.Compile())
.WithNormalizationStep()
.WithProhibitedValueStep(ValueRangeTable.Create(
Prohibited.C_1_1,
Prohibited.C_1_2,
Prohibited.C_2_1,
Prohibited.C_2_2,
Prohibited.C_3,
Prohibited.C_4,
Prohibited.C_5,
Prohibited.C_6,
Prohibited.C_7,
Prohibited.C_8,
Prohibited.C_9,
NodeprepProhibited))
.WithBidirectionalStep()
.WithProhibitedValueStep(ValueRangeTable.Create(
Unassigned.A_1))
.Compile());
}
private void ChooseMappingFile()
{
var dialog = new OpenFileDialog();
dialog.Title = "Mappingファイルを開く";
dialog.Filter = "CSVファイル(*.csv)|*.csv";
if (dialog.ShowDialog() == true)
{
MappingFilePath.Value = dialog.FileName;
using (var reader = new StreamReader(MappingFilePath.Value))
using (var csv = new CsvReader(reader))
{
MappingTable.Clear();
var records = csv.GetRecords <dynamic>();
foreach (var r in records)
{
MappingTable[r.Old] = r.New;
}
}
}
else
{
MappingFilePath.Value = string.Empty;
}
}
public static string SupImportQueryForProductId(MappingTable mappingTable, DataRow row)
{
if (mappingTable.TableName.ToUpperInvariant() != "INGREDIENT")
{
return(null);
}
int?supplierCodeOrdinal = mappingTable.ColumnOrdinalOf("supplier_code");
string supplierCode = string.Empty;
if (supplierCodeOrdinal != null)
{
supplierCode = row[(int)supplierCodeOrdinal].ToString();
}
if (string.IsNullOrWhiteSpace(supplierCode))
{
supplierCode = "|=============|"; // this should never match with the database
}
//Following query is to make sure we update data only for correct suppliers and not disturbing other suppliers if they have same supplier code.
return(string.Format(@"select top 1 @product_id = product_id,@ingredient_id = i.ingredient_id from ingredient i
where i.supplier_code = {0} and supplier_id IN (
select isupp.supplier_id from ingredient_import ii JOIN import_supplier isupp
ON ii.ingredient_import_id = isupp.ingredient_import_id
WHERE is_supplier_file = 1 and import_status_id =2 )", supplierCode.WithSqlSyntax(Datatype.String)
));
}
public override string GetTableName(MappingEntity entity)
{
AttributeMappingEntity entity2 = (AttributeMappingEntity)entity;
MappingTable table = entity2.Tables.FirstOrDefault <MappingTable>();
return(this.GetTableName(table));
}
internal static ObjectId NewObjectId(Type t, Class cl, DataRow row, MappingTable mt, TypeManager tm)
{
if (cl.SystemType == null)
{
throw new InternalException(16, "ObjectIdFactory.NewObjectId: cl.SystemType is null.");
}
ObjectId result;
if (cl.Oid.IsDependent)
{
result = new ObjectId(new DependentKey(t, cl, tm));
}
else
{
result = new ObjectId(new MultiKey(t, cl, tm));
}
Key key = result.Id;
int i = 0;
new ForeignKeyIterator(mt).Iterate(delegate(ForeignKeyColumn fkColumn, bool isLastElement)
{
object o = row[fkColumn.Name];
AssignKeyValue(cl, key, i, o);
i++;
});
return(result);
}
public void General()
{
MappingTable mt = new MappingTable();
mt.Add("1", "v1");
mt.Add("2", "v2");
var json = mt.ToJson();
json = @"{
""valueUnique"": false,
""items"": [
{
""s"": ""1"",
""m"": ""v1""
},
{
""s"": ""2"",
""m"": ""v2""
}
],
""caseSensitive"": false
}";
var mt2 = json.TryConvertJsonToObject <MappingTable <string> >();
Assert.IsNotNull(mt2);
}
public static string QueryForProductId(MappingTable mappingTable, DataRow row)
{
if (mappingTable.TableName.ToUpperInvariant() != "INGREDIENT")
{
return(null);
}
int?starchefKeyOrdinal = mappingTable.ColumnOrdinalOf("product_id");
int?supplierNameOrdinal = mappingTable.ColumnOrdinalOf("supplier_id");
int?supplierCodeOrdinal = mappingTable.ColumnOrdinalOf("supplier_code");
string starchefKey = string.Empty;
string supplierName = string.Empty;
string supplierCode = string.Empty;
if (starchefKeyOrdinal.HasValue)
{
starchefKey = row[starchefKeyOrdinal.Value].ToString();
}
if (supplierNameOrdinal.HasValue)
{
supplierName = row[supplierNameOrdinal.Value].ToString();
}
if (supplierCodeOrdinal.HasValue)
{
supplierCode = row[supplierCodeOrdinal.Value].ToString();
}
if (string.IsNullOrWhiteSpace(starchefKey))
{
starchefKey = "0";
}
if (string.IsNullOrEmpty(supplierName))
{
supplierName = string.Empty;
}
if (string.IsNullOrEmpty(supplierCode))
{
supplierCode = "|=============|"; // this should never match with the database
}
return(string.Format(@"IF(EXISTS(SELECT 1 FROM ingredient i where i.product_id = {0}))
BEGIN
select @product_id = product_id,@ingredient_id = i.ingredient_id
from ingredient i
where i.product_id = {0}
END
ELSE
BEGIN
select top 1 @product_id = product_id,@ingredient_id = i.ingredient_id
from ingredient i
JOIN supplier s ON s.supplier_id = i.supplier_id
where s.supplier_name = {1} AND i.supplier_code = {2}
order by i.product_id
END",
starchefKey, supplierName.WithSqlSyntax(Datatype.String), supplierCode.WithSqlSyntax(Datatype.String)));
}
public ImportDataException PriceValidUntilFutureDateIsValid(MappingTable mappingTable, DataRow row)
{
if (mappingTable.TableName.ToUpperInvariant() != "INGREDIENT_INTERNAL_SPECIFICATION")
{
return(null);
}
int? effectiveDateOrdinal = mappingTable.ColumnOrdinalOf("price_valid_end_date");
string datestring = "";
if (effectiveDateOrdinal != null)
{
datestring = row[(int)effectiveDateOrdinal].ToString().Trim();
}
DateTime date;
string columnName = mappingTable.ColumnNameOf("price_valid_end_date");
string mappingName = mappingTable.MappingNameOf("price_valid_end_date");
int dateDays = 0;
if (DateTime.TryParseExact(datestring, "d/M/yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
dateDays = DateDiffFromToday(date);
}
else if (DateTime.TryParseExact(datestring, "d MMMM yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
dateDays = DateDiffFromToday(date);
}
else if (DateTime.TryParseExact(datestring, "d MM yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
dateDays = DateDiffFromToday(date);
}
else if (DateTime.TryParseExact(datestring, "d MMM yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
dateDays = DateDiffFromToday(date);
}
else if (DateTime.TryParseExact(datestring, "d-MMM-yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
dateDays = DateDiffFromToday(date);
}
else if (DateTime.TryParseExact(datestring, "d-MMM-yy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
dateDays = DateDiffFromToday(date);
}
if (dateDays < 0)
{
return(new ImportDataException
{
ExceptionType = ExceptionType.InvalidFutureDate,
TemplateColumnName = columnName,
IsValid = false,
TemplateMappingColumn = mappingName
});
}
return(null);
}
public void WillNotReplaceValuesNotMapped()
{
var input = "this will not be replaced";
var step = new MappingStep(MappingTable.Create(Tables.B_1));
var output = step.Run(input);
Assert.Equal(input, output);
}
public void WillNotReplaceValuesNotMapped()
{
const string input = "this will not be replaced";
var step = new MappingStep(MappingTable.Create(Mapping.B1));
var output = step.Run(input);
output.ShouldBe(input);
}
public void AddMappingTable(MappingTable mappingTable)
{
try
{
DatabaseHelper.Insert <MappingTable>(mappingTable);
}
catch (Exception ex) { throw new Exception(ex.Message, ex); }
}
private ImportDataException ValidateDeliveryToWarehouseDate(MappingTable mappingTable, DataRow row)
{
if (mappingTable.TableName.ToUpperInvariant() != "INGREDIENT_INTERNAL_SPECIFICATION")
{
return(null);
}
int? deliveryToWarehouseDateOrdinal = mappingTable.ColumnOrdinalOf("delivery_to_warehouse_date");
string datestring = "";
if (deliveryToWarehouseDateOrdinal != null)
{
datestring = row[(int)deliveryToWarehouseDateOrdinal].ToString().Trim();
}
if (string.IsNullOrEmpty(datestring))
{
return(null);
}
DateTime date;
if (DateTime.TryParseExact(datestring, "d/M/yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
return(null);
}
if (DateTime.TryParseExact(datestring, "d MMMM yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
return(null);
}
if (DateTime.TryParseExact(datestring, "d MM yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
return(null);
}
if (DateTime.TryParseExact(datestring, "d MMM yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
return(null);
}
if (DateTime.TryParseExact(datestring, "d-MMM-yyyy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
return(null);
}
if (DateTime.TryParseExact(datestring, "d-MMM-yy", new CultureInfo("en-GB"), DateTimeStyles.None, out date))
{
return(null);
}
string columnName = mappingTable.ColumnNameOf("delivery_to_warehouse_date");
string mappingName = mappingTable.MappingNameOf("delivery_to_warehouse_date");
return(new ImportDataException
{
ExceptionType = ExceptionType.InvalidDateFormat,
TemplateColumnName = columnName,
IsValid = false,
TemplateMappingColumn = mappingName
});
}
public void WillReplaceValuesWithMultipleReplacements()
{
var input = "this value: " + Convert.ToChar(0x00DF) + " will be replaced";
var expected = "this value: " + Convert.ToChar(0x0073) + Convert.ToChar(0x0073) + " will be replaced";
var step = new MappingStep(MappingTable.Create(Tables.B_2));
var output = step.Run(input);
Assert.Equal(expected, output);
}
public void WillReplaceValuesMappedToNothing()
{
var input = "this value: " + Convert.ToChar(0x180B) + " will be replaced";
var expected = "this value: will be replaced";
var step = new MappingStep(MappingTable.Create(Tables.B_1));
var output = step.Run(input);
Assert.Equal(expected, output);
}
public MappingTableNode(MappingTable mt) : base("MappingTable", mt)
{
this.ImageIndex = 13;
this.SelectedImageIndex = 13;
foreach (ForeignKeyColumn fkCol in mt.ChildForeignKeyColumns)
{
this.Nodes.Add(new ColumnNode(this, fkCol));
}
}
public void WillReplaceValues()
{
var input = $"this value: {Convert.ToChar(0x0041)} will be replaced";
var expected = $"this value: {Convert.ToChar(0x0061)} will be replaced";
var step = new MappingStep(MappingTable.Create(Mapping.B2));
var output = step.Run(input);
output.ShouldBe(expected);
}
public static string Get(MappingTable mappingTable, string columnName)
{
IProvider provider = mappingTable.Parent.Parent.Provider;
StringBuilder sb = new StringBuilder(provider.GetQuotedName(mappingTable.TableName));
sb.Append('.');
sb.Append(provider.GetQuotedName(columnName));
return(sb.ToString());
}
public void WillReplaceValuesMappedToNothing()
{
var input = $"this value: {Convert.ToChar(0x180B)} will be replaced";
const string expected = "this value: will be replaced";
var step = new MappingStep(MappingTable.Create(Mapping.B1));
var output = step.Run(input);
output.ShouldBe(expected);
}
public void WillReplaceWithMultipleCharacters()
{
var input = $"this value: {Convert.ToChar(0x00DF)} will be replaced";
var expected = $"this value: {Convert.ToChar(0x0073)}{Convert.ToChar(0x0073)} will be replaced";
var step = new MappingStep(MappingTable.Create(Mapping.B2));
var output = step.Run(input);
output.ShouldBe(expected);
}
private ImportDataException ValidatePConversionUnit(MappingTable mappingTable, DataRow row)
{
if (mappingTable.TableName.ToUpperInvariant() != "PRODUCT" && mappingTable.TableName.ToUpperInvariant() != "PCONVERSION")
{
return(null);
}
if (mappingTable.TableName.ToUpperInvariant() == "PRODUCT")
{
int?unitIdOrdinal = mappingTable.ColumnOrdinalOf("unit_id");
if (unitIdOrdinal == null)
{
return(null);
}
suppQtyUnit = row[Convert.ToInt32(unitIdOrdinal)].ToString().Trim();
}
else if (mappingTable.TableName.ToUpperInvariant() == "PCONVERSION")
{
if (string.IsNullOrEmpty(suppQtyUnit))
{
return(null);
}
int?unitIdOrdinal = mappingTable.ColumnOrdinalOf("unit_id");
if (unitIdOrdinal == null)
{
return(null);
}
string pconversionNum = row[Convert.ToInt32(unitIdOrdinal - 2)].ToString().Trim();
string pconversionQty = row[Convert.ToInt32(unitIdOrdinal) - 1].ToString().Trim();
string pconversionUnit = row[Convert.ToInt32(unitIdOrdinal)].ToString().Trim();
if (string.IsNullOrEmpty(pconversionNum) || string.IsNullOrEmpty(pconversionNum) || string.IsNullOrEmpty(pconversionNum))
{
mappingTable.MappingColumns[0].IgnoreThisTable = true;
return(null);
}
using (var pcService = new PConversionService(_config.TargetConnectionString))
{
if (!pcService.ValidatePConversionUnit(suppQtyUnit, pconversionUnit))
{
string columnName = mappingTable.ColumnNameOf("unit_id");
string mappingName = mappingTable.MappingNameOf("unit_id");
return(new ImportDataException
{
ExceptionType = ExceptionType.InvalidPConversionUnit,
TemplateColumnName = columnName,
IsValid = false,
TemplateMappingColumn = mappingName
});
}
}
}
return(null);
}
public override IEnumerable <string> GetExtensionKeyColumnNames(MappingTable table)
{
ExtensionTableAttribute attribute = ((AttributeMappingTable)table).Attribute as ExtensionTableAttribute;
if (attribute == null)
{
return(new string[0]);
}
return(attribute.KeyColumns.Split(separators));
}
public static int?ColumnOrdinalOf(this MappingTable mappingTable, string columnName)
{
MappingColumn column = mappingTable.MappingColumns.Where(c => c.StarchefColumnName.ToUpperInvariant() == columnName.ToUpperInvariant()).FirstOrDefault();
if (column != null)
{
return(column.TemplateColumnOrdinal);
}
return(null);
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
try
{
labelMessage.Text = string.Empty;
using (MappingTableRT receiverTransfer = new MappingTableRT())
{
hdIsEdit.Value = "true";
MappingTable mapping = CreateMappingTable();
if (mapping != null)
{
// if (receiverTransfer.IsMappingTableNameExistOtherRows(mapping.IID, mapping.Name) && receiverTransfer.IsMappingNameExistOtherRows(mapping.IID, mapping.Name))
// {
// labelMessage.Text = "Mapping Code " + txtCode.Text + " & Name " + txtName.Text + " Already Exists!";
// labelMessage.ForeColor = System.Drawing.Color.Red;
// return;
// }
// if (receiverTransfer.IsMappingCodeExistOtherRows(mapping.IID, mapping.Code))
// {
// labelMessage.Text = "Mapping Code " + txtCode.Text + " Already Exists!";
// labelMessage.ForeColor = System.Drawing.Color.Red;
// return;
// }
// else if (receiverTransfer.IsMappingNameExistOtherRows(mapping.IID, mapping.Name))
// {
// labelMessage.Text = "Mapping Name " + txtName.Text + " Already Exists!";
// labelMessage.ForeColor = System.Drawing.Color.Red;
// return;
// }
//else
//{
receiverTransfer.UpdateMappingTable(mapping);
labelMessage.Text = "Data successfully updated...";
labelMessage.ForeColor = System.Drawing.Color.Green;
//}
}
else
{
labelMessage.Text = "Data not updated...";
labelMessage.ForeColor = System.Drawing.Color.Red;
}
}
ClearField();
SetButton();
btnSave.Visible = true;
LoadMappingTable();
}
catch (Exception ex)
{
labelMessage.Text = "Error : " + ex.Message;
labelMessage.ForeColor = System.Drawing.Color.Red;
}
}
public Matrix(Switch switchElement, Configuration.NetworkElement networkElement)
{
this.switchElement = switchElement;
mappingTable = new MappingTable();
foreach (Configuration.RoutingEntry entry in networkElement.RoutingTable)
{
mappingTable.Add(new HalfEntryMapping(entry.PortIn, entry.VpiIN, entry.VciIN), new HalfEntryMapping(entry.PortOut, entry.VpiOUT, entry.VciOUT));
}
}
public override IEnumerable <string> GetExtensionKeyColumnNames(MappingTable table)
{
var attr = (table as AttributeMappingTable).Attribute as TableExtensionAttribute;
if (attr == null)
{
return(new string[] { });
}
return(attr.KeyColumns.Split(separators));
}
public override IEnumerable <MemberInfo> GetExtensionRelatedMembers(MappingTable table)
{
AttributeMappingTable amt = (AttributeMappingTable)table;
ExtensionTableAttribute attribute = amt.Attribute as ExtensionTableAttribute;
if (attribute == null)
{
return(new MemberInfo[0]);
}
return(from n in attribute.RelatedKeyColumns.Split(separators) select this.GetMemberForColumn(amt.Entity, n));
}
public void CreateDelimitingRule(string rule, string delimiters)
{
// add rule to parsing table
ParsingTable.AddParsingTableRow(rule, true, true, delimiters);
// add rule to mapping table
foreach (string field in FieldList)
{
MappingTable.AddMappingTableRow(rule, field, -1, null, "en-US");
}
}
internal AdapterTableEntry(Type type, IDictionary<ADServerType, MappingTable<AttributeConverterEntry>> attributeTable)
{
this._methodNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
this._properties = new Dictionary<string, PropertyInfo>(StringComparer.OrdinalIgnoreCase);
if (attributeTable != null)
{
this._attributeTable = new Dictionary<ADServerType, MappingTable<AttributeConverterEntry>>();
foreach (KeyValuePair<ADServerType, MappingTable<AttributeConverterEntry>> key in _attributeTable)
{
MappingTable<AttributeConverterEntry> mappingTable = new MappingTable<AttributeConverterEntry>();
Dictionary<string, AttributeConverterEntry>.KeyCollection.Enumerator enumerator = key.Value.Keys.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
string str = enumerator.Current;
mappingTable.Add(str, key.Value[str]);
}
}
finally
{
enumerator.Dispose();
}
this._attributeTable.Add(key.Key, mappingTable);
}
}
else
{
this._attributeTable = null;
}
PropertyInfo[] properties = type.GetProperties();
for (int i = 0; i < (int)properties.Length; i++)
{
PropertyInfo propertyInfo = properties[i];
this._properties.Add(propertyInfo.Name, propertyInfo);
}
MethodInfo[] methods = type.GetMethods();
for (int j = 0; j < (int)methods.Length; j++)
{
MethodInfo methodInfo = methods[j];
this._methodNames.Add(methodInfo.Name);
}
}
public abstract bool IsExtensionTable(MappingTable table);
public abstract string GetTableName(MappingTable table);
public abstract IEnumerable<MemberInfo> GetExtensionRelatedMembers(MappingTable table);
public abstract string GetExtensionRelatedAlias(MappingTable table);
public abstract IEnumerable<string> GetExtensionKeyColumnNames(MappingTable table);
public abstract string GetAlias(MappingTable table);
public override string GetExtensionRelatedAlias(MappingTable table)
{
var attr = ((AttributeMappingTable)table).Attribute as ExtensionTableAttribute;
return (attr != null) ? attr.RelatedAlias : null;
}
// make a variable declaration / initialization for dependent generated values
private CommandExpression GetDependentGeneratedVariableDeclaration(MappingEntity entity, MappingTable table, List<MemberInfo> members, Expression instance, Dictionary<MemberInfo, Expression> map)
{
// first make command that retrieves the generated ids if any
DeclarationCommand genIdCommand = null;
var generatedIds = this.mapping.GetMappedMembers(entity).Where(m => this.mapping.IsPrimaryKey(entity, m) && this.mapping.IsGenerated(entity, m)).ToList();
if (generatedIds.Count > 0)
{
genIdCommand = this.GetGeneratedIdCommand(entity, members, map);
// if that's all there is then just return the generated ids
if (members.Count == generatedIds.Count)
{
return genIdCommand;
}
}
// next make command that retrieves the generated members
// only consider members that were not generated ids
members = members.Except(generatedIds).ToList();
var tableAlias = new TableAlias();
var tex = new TableExpression(tableAlias, entity, this.mapping.GetTableName(table));
Expression where = null;
if (generatedIds.Count > 0)
{
where = generatedIds.Select((m, i) =>
this.GetMemberExpression(tex, entity, m).Equal(map[m])
).Aggregate((x, y) => x.And(y));
}
else
{
where = this.GetIdentityCheck(tex, entity, instance);
}
TableAlias selectAlias = new TableAlias();
var columns = new List<ColumnDeclaration>();
var variables = new List<VariableDeclaration>();
foreach (var mi in members)
{
ColumnExpression col = (ColumnExpression)this.GetMemberExpression(tex, entity, mi);
columns.Add(new ColumnDeclaration(this.mapping.GetColumnName(entity, mi), col, col.QueryType));
ColumnExpression vcol = new ColumnExpression(col.Type, col.QueryType, selectAlias, col.Name);
variables.Add(new VariableDeclaration(mi.Name, col.QueryType, vcol));
map.Add(mi, new VariableExpression(mi.Name, col.Type, col.QueryType));
}
var genMembersCommand = new DeclarationCommand(variables, new SelectExpression(selectAlias, columns, tex, where));
if (genIdCommand != null)
{
return new BlockCommand(genIdCommand, genMembersCommand);
}
return genMembersCommand;
}
public override IEnumerable<MemberInfo> GetExtensionRelatedMembers(MappingTable table)
{
var amt = (AttributeMappingTable)table;
var attr = amt.Attribute as ExtensionTableAttribute;
if (attr == null) return new MemberInfo[] { };
return attr.RelatedKeyColumns.Split(separators).Select(n => this.GetMemberForColumn(amt.Entity, n));
}
public override IEnumerable<string> GetExtensionKeyColumnNames(MappingTable table)
{
var attr = ((AttributeMappingTable)table).Attribute as ExtensionTableAttribute;
if (attr == null) return new string[] { };
return attr.KeyColumns.Split(separators);
}
public override string GetTableName(MappingTable table)
{
var amt = (AttributeMappingTable)table;
return this.GetTableName(amt.Entity, amt.Attribute);
}
public override string GetAlias(MappingTable table)
{
return ((AttributeMappingTable)table).Attribute.Alias;
}
private Expression GetIdentityCheck(TableExpression root, MappingEntity entity, Expression instance, MappingTable table)
{
if (this.mapping.IsExtensionTable(table))
{
var keyColNames = this.mapping.GetExtensionKeyColumnNames(table).ToArray();
var relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToArray();
Expression where = null;
for (int i = 0, n = keyColNames.Length; i < n; i++)
{
var relatedMember = relatedMembers[i];
var cex = new ColumnExpression(TypeHelper.GetMemberType(relatedMember), this.GetColumnType(entity, relatedMember), root.Alias, keyColNames[n]);
var nex = this.GetMemberExpression(instance, entity, relatedMember);
var eq = cex.Equal(nex);
where = (where != null) ? where.And(eq) : where;
}
return where;
}
else
{
return base.GetIdentityCheck(root, entity, instance);
}
}
public override bool IsExtensionTable(MappingTable table)
{
return ((AttributeMappingTable)table).Attribute is ExtensionTableAttribute;
}
private IEnumerable<ColumnAssignment> GetRelatedColumnAssignments(Expression expr, MappingEntity entity, MappingTable table, Dictionary<MemberInfo, Expression> map)
{
if (this.mapping.IsExtensionTable(table))
{
var keyColumns = this.mapping.GetExtensionKeyColumnNames(table).ToArray();
var relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToArray();
for (int i = 0, n = keyColumns.Length; i < n; i++)
{
MemberInfo member = relatedMembers[i];
Expression exp = map[member];
yield return new ColumnAssignment((ColumnExpression)this.GetMemberExpression(expr, entity, member), exp);
}
}
}
/// <summary>
/// SqlSugar的功能介绍
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
//设置执行的DEMO
string switchOn = "select";
IDemos demo = null;
switch (switchOn)
{
/****************************基本功能**************************************/
//查询
case "select": demo = new Select(); break;
//删除
case "delete": demo = new Delete(); break;
//插入
case "insert": demo = new Insert(); break;
//更新
case "update": demo = new Update(); break;
//插入或者更新
case "insertorupdate": demo = new InsertOrUpdate(); break;
//基层函数的用法
case "ado": demo = new Ado(); break;
//主从模式
case "ms": demo = new MsterSlave(); break;
//事务
case "tran": demo = new Tran(); break;
//创建实体函数
case "createclass": demo = new CreateClass(); break;
//T4生成 http://www.cnblogs.com/sunkaixuan/p/5751503.html
//日志记录
case "log": demo = new Log(); break;
//枚举支持
case "enum": demo = new EnumDemo(); break;
/****************************实体映射**************************************/
//自动排除非数据库列
case "ignoreerrorcolumns": demo = new IgnoreErrorColumns(); break;
//别名表
case "mappingtable":demo=new MappingTable(); break;
//别名列
case "mappingcolumns": demo = new MappingColumns(); break;
//通过属性的方法设置别名表和别名字段
case "attributesmapping": demo = new AttributesMapping(); break;
/****************************业务应用**************************************/
//过滤器
case "filter": demo = new Filter(); break;
//过滤器2
case "filter2": demo = new Filter2(); break;
//流水号功能
case "serialnumber": demo = new SerialNumber(); break;
//多语言支持 http://www.cnblogs.com/sunkaixuan/p/5709583.html
//多库并行计算 http://www.cnblogs.com/sunkaixuan/p/5046517.html
//配置与实例的用法
case "initconfig": demo = new InitConfig(); break;
/****************************支持**************************************/
//公开函数数
case "pubmethod": demo = new PubMethod(); break;
//Sql2012分页的支持
case "sqlpagemodel": demo=new SqlPageModel(); break;
//设置ToJson的日期格式
case "serializerdateformat":demo =new SerializerDateFormat();break;
/****************************测试用例**************************************/
case "test": demo = new Test(); break;
default: Console.WriteLine("switchOn的值错误，请输入正确的 case"); break;
}
//执行DEMO
demo.Init();
//更多例子请查看API
//http://www.cnblogs.com/sunkaixuan/p/5654695.html
Console.WriteLine("执行成功请关闭窗口");
Console.ReadKey();
}
