internal static void BuildMapping_EntitySet(SchemaMapping mapping, Schema conceptual, Schema storage)
{
mapping.EntityContainerMapping.EntitySetMappings.ForEach(x =>
{
// SET Entity Set
var conceptualSet = conceptual.EntityContainer.Index_EntitySets_Name[x.Name];
x.ConceptualSet = conceptualSet;
x.EntityTypeMappings.ForEach(y =>
{
if (y.MappingFragment != null)
{
var isGenericType = y.TypeName.StartsWith("IsTypeOf(");
var typeName = isGenericType ? y.TypeName.SubstringLastIndexOf(".").Replace(")", "") : y.TypeName.SubstringLastIndexOf(".");
var entityType = conceptual.Index_EntityTypes_Name[typeName];
y.EntityType = entityType;
entityType.EntityTypeMapping = y;
if (isGenericType)
{
entityType.GenericEntitySetMapping = y;
}
var storeEntitySet = storage.EntityContainer.Index_EntitySets_Name[y.MappingFragment.StoreEntitySetName];
y.MappingFragment.StoreEntitySet = storeEntitySet;
}
});
});
}
public void Test_mapping_complex_type_with_two_simple_elements_to_two_accs()
{
var mappingFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_complex_type_with_two_simple_elements_to_two_accs\mapping.mfd");
var xsdFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_complex_type_with_two_simple_elements_to_two_accs\source.xsd");
SchemaMapping mappings = CreateSchemaMapping(mappingFileName, xsdFileName);
SimpleTypeToCdtMapping stringMapping = new SimpleTypeToCdtMapping("String", cdtText);
var expectedSimpleTypeMappings = new List <SimpleTypeToCdtMapping>
{
stringMapping,
};
var addressTypeMapping = new ComplexTypeToMaMapping("Address", "AddressType",
new List <ElementMapping>
{
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("CityName", null, XsdObjectType.Element, null), bccCityName, stringMapping),
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("PersonName", null, XsdObjectType.Element, null), bccPartyName, stringMapping),
});
var expectedComplexTypeMappings = new List <IMapping>
{
addressTypeMapping,
};
var expectedRootElementMapping = new AsmaMapping(new SourceItem("Address", null, XsdObjectType.Element, null))
{
TargetMapping = addressTypeMapping
};
AssertMappings(mappings, expectedComplexTypeMappings, expectedSimpleTypeMappings, expectedRootElementMapping);
}
public LoadableTable(DataContext context, SchemaMapping mapping)
{
Mapping = mapping;
Synchronizer = new TableSynchronizer(CreateTable(), Mapping, sqlProvider);
context.Tables.AddTable(Synchronizer.Table);
}
internal ConstDataSet LoadDataSetFromXml()
{
var ds = new ConstDataSet();
ds.ReadXml(new StringReader(DataSetXml), XmlReadMode.Auto);
if (DataSetFactory != null)
{
var dsWithSchema = new ConstDataSet();
foreach (DataTable t in ds.Tables)
{
var schemaTblName = t.TableName;
if (SchemaMapping.ContainsKey(schemaTblName))
{
schemaTblName = SchemaMapping[schemaTblName];
}
var tblDs = DataSetFactory.GetDataSet(schemaTblName);
if (tblDs != null)
{
var schemaTbl = tblDs.Tables[schemaTblName].Clone();
schemaTbl.TableName = t.TableName;
dsWithSchema.Tables.Add(schemaTbl);
}
}
dsWithSchema.ReadXml(new StringReader(DataSetXml), XmlReadMode.Auto);
}
return(ds);
}
public void Test_mapping_complex_type_with_complex_element_to_single_acc()
{
var mappingFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_complex_type_with_complex_element_to_single_acc\mapping.mfd");
var xsdFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_complex_type_with_complex_element_to_single_acc\invoice\maindoc\UBL-Invoice-2.0.xsd");
SchemaMapping mappings = CreateSchemaMapping(mappingFileName, xsdFileName);
var expectedSimpleTypeMappings = new List <SimpleTypeToCdtMapping>();
var issueDateTypeMapping = new ComplexTypeToCdtMapping("Issue", "IssueDateType", new List <ElementMapping>())
{
TargetCdt = cdtDateTime
};
var orderReferenceTypeMapping = new ComplexTypeToAccMapping("OrderReference", "OrderReferenceType",
new List <ElementMapping>
{
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("IssueDate", null, XsdObjectType.Element, null), bccIssue, issueDateTypeMapping),
});
var expectedComplexTypeMappings = new List <IMapping>
{
issueDateTypeMapping,
orderReferenceTypeMapping,
};
var expectedRootElementMapping = new AsmaMapping(new SourceItem("OrderReference", null, XsdObjectType.Element, null))
{
TargetMapping = orderReferenceTypeMapping
};
AssertMappings(mappings, expectedComplexTypeMappings, expectedSimpleTypeMappings, expectedRootElementMapping);
}
public void Test_mapping_simple_element_and_attributes_to_acc_with_mapping_function_split()
{
var mappingFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_simple_element_and_attributes_to_acc_with_mapping_function_split\mapping.mfd");
var xsdFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_simple_element_and_attributes_to_acc_with_mapping_function_split\source.xsd");
SchemaMapping mappings = CreateSchemaMapping(mappingFileName, xsdFileName);
SimpleTypeToCdtMapping stringMapping = new SimpleTypeToCdtMapping("String", cdtText);
var expectedSimpleTypeMappings = new List <SimpleTypeToCdtMapping>
{
stringMapping,
};
var addressTypeMapping = new ComplexTypeToAccMapping("Address", "AddressType",
new List <ElementMapping>
{
new SplitMapping(new SourceItem("Street", null, XsdObjectType.Element, null), new[] { bccStreetName, bccBuildingNumber }, new [] { stringMapping, stringMapping }),
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("Town", null, XsdObjectType.Element, null), bccCityName, stringMapping),
});
var expectedComplexTypeMappings = new List <IMapping>
{
addressTypeMapping,
};
var expectedRootElementMapping = new AsmaMapping(new SourceItem("Address", null, XsdObjectType.Element, null))
{
TargetMapping = addressTypeMapping
};
AssertMappings(mappings, expectedComplexTypeMappings, expectedSimpleTypeMappings, expectedRootElementMapping);
}
public void Test_mapping_complex_type_with_simple_elements_and_attributes_to_cdt()
{
var mappingFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_complex_type_with_simple_elements_and_attributes_to_cdt\mapping.mfd");
var xsdFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_complex_type_with_simple_elements_and_attributes_to_cdt\source.xsd");
SchemaMapping mappings = CreateSchemaMapping(mappingFileName, xsdFileName);
var textTypeMapping = new ComplexTypeToCdtMapping("Text", "TextType",
new List <ElementMapping>
{
new AttributeOrSimpleElementToSupMapping(new SourceItem("Language", null, XsdObjectType.Attribute, null), supTextLanguage),
new AttributeOrSimpleElementToSupMapping(new SourceItem("LanguageLocale", null, XsdObjectType.Attribute, null), supTextLanguageLocale),
});
var addressTypeMapping = new ComplexTypeToAccMapping("Address", "AddressType",
new List <ElementMapping>
{
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("CityName", null, XsdObjectType.Element, null), bccCityName, textTypeMapping),
});
var expectedComplexTypeMappings = new List <IMapping>
{
textTypeMapping,
addressTypeMapping,
};
var expectedRootElementMapping = new AsmaMapping(new SourceItem("Address", null, XsdObjectType.Element, null))
{
TargetMapping = addressTypeMapping
};
AssertMappings(mappings, expectedComplexTypeMappings, new List <SimpleTypeToCdtMapping>(), expectedRootElementMapping);
}
public void ColumnEventsTest()
{
var schema = new TableSchema("ColumnEventsTest");
schema.Columns.AddValueColumn("Col1", typeof(int), 5);
schema.Columns.AddValueColumn("Col2", typeof(int), 5);
var cc = schema.Columns.AddCalculatedColumn <int>("Calculated", row => 4);
schema.Columns.AddValueColumn("Col4", typeof(int), 5);
var mapping = new SchemaMapping(schema);
var cc2 = schema.Columns.AddCalculatedColumn <long>("Other Calculated", row => row.Field <int>("Col1") * (long)row["Col2"]);
Assert.AreEqual(3, mapping.Columns.Count);
var lastCol = schema.Columns.AddValueColumn("Col6", typeof(int), 7);
Assert.AreEqual(4, mapping.Columns.Count);
Assert.AreEqual(lastCol, mapping.Columns[3].Column);
schema.Columns.RemoveColumn(cc2);
schema.Columns.RemoveColumn("Col2");
Assert.AreEqual(3, mapping.Columns.Count);
Assert.AreEqual(lastCol, mapping.Columns[2].Column);
mapping.Columns.RemoveMapping(lastCol);
Assert.AreEqual(2, mapping.Columns.Count);
Assert.AreEqual(schema.Columns["Col4"], mapping.Columns[1].Column);
Assert.AreEqual("Col4", mapping.Columns[1].SqlName);
}
private SchemaMapping FillMapping(DataSet dataset, DataTable datatable, string srcTable, DataReaderContainer dataReader, int schemaCount, DataColumn parentChapterColumn, object parentChapterValue)
{
SchemaMapping mapping = null;
if (_hasFillErrorHandler)
{
try
{
// only try-catch if a FillErrorEventHandler is registered so that
// in the default case we get the full callstack from users
mapping = FillMappingInternal(dataset, datatable, srcTable, dataReader, schemaCount, parentChapterColumn, parentChapterValue);
}
catch (Exception e)
{
//
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
ADP.TraceExceptionForCapture(e);
OnFillErrorHandler(e, null, null);
}
}
else
{
mapping = FillMappingInternal(dataset, datatable, srcTable, dataReader, schemaCount, parentChapterColumn, parentChapterValue);
}
return(mapping);
}
static StagedPerson()
{
#region Create Schema
Schema = new TypedSchema <StagedPerson>("StagedPeople");
Schema.PrimaryKey = StagedPersonIdColumn = Schema.Columns.AddValueColumn("StagedPersonId", typeof(Guid), null);
StagedPersonIdColumn.Unique = true;
StagedPersonIdColumn.AllowNulls = false;
PersonColumn = Schema.Columns.AddForeignKey("Person", Person.Schema, "StagedPeople");
PersonColumn.AllowNulls = true;
HisNameColumn = Schema.Columns.AddValueColumn("HisName", typeof(String), null);
HisNameColumn.AllowNulls = true;
HerNameColumn = Schema.Columns.AddValueColumn("HerName", typeof(String), null);
HerNameColumn.AllowNulls = true;
LastNameColumn = Schema.Columns.AddValueColumn("LastName", typeof(String), null);
LastNameColumn.AllowNulls = false;
FullNameColumn = Schema.Columns.AddValueColumn("FullName", typeof(String), null);
FullNameColumn.AllowNulls = false;
AddressColumn = Schema.Columns.AddValueColumn("Address", typeof(String), null);
AddressColumn.AllowNulls = true;
CityColumn = Schema.Columns.AddValueColumn("City", typeof(String), null);
CityColumn.AllowNulls = true;
StateColumn = Schema.Columns.AddValueColumn("State", typeof(String), null);
StateColumn.AllowNulls = true;
ZipColumn = Schema.Columns.AddValueColumn("Zip", typeof(String), null);
ZipColumn.AllowNulls = true;
PhoneColumn = Schema.Columns.AddValueColumn("Phone", typeof(String), "");
PhoneColumn.AllowNulls = false;
#endregion
#region Create SchemaMapping
SchemaMapping = new SchemaMapping(Schema, false);
SchemaMapping.SqlName = "StagedPeople";
SchemaMapping.SqlSchemaName = "BillingMigration";
SchemaMapping.Columns.AddMapping(StagedPersonIdColumn, "StagedPersonId");
SchemaMapping.Columns.AddMapping(PersonColumn, "PersonId");
SchemaMapping.Columns.AddMapping(HisNameColumn, "HisName");
SchemaMapping.Columns.AddMapping(HerNameColumn, "HerName");
SchemaMapping.Columns.AddMapping(LastNameColumn, "LastName");
SchemaMapping.Columns.AddMapping(FullNameColumn, "FullName");
SchemaMapping.Columns.AddMapping(AddressColumn, "Address");
SchemaMapping.Columns.AddMapping(CityColumn, "City");
SchemaMapping.Columns.AddMapping(StateColumn, "State");
SchemaMapping.Columns.AddMapping(ZipColumn, "Zip");
SchemaMapping.Columns.AddMapping(PhoneColumn, "Phone");
#endregion
SchemaMapping.SetPrimaryMapping(SchemaMapping);
}
internal static void BuildMapping_EntitySet(SchemaMapping mapping, Schema conceptual, Schema storage)
{
mapping.EntityContainerMapping.EntitySetMappings.ForEach(x =>
{
// SET Entity Set
var conceptualSet = conceptual.EntityContainer.Index_EntitySets_Name[x.Name];
x.ConceptualSet = conceptualSet;
conceptualSet.EntitySetMapping = x;
x.EntityTypeMappings.ForEach(y =>
{
if (y.MappingFragment != null)
{
var isGenericType = y.TypeName.StartsWith("IsTypeOf(", StringComparison.InvariantCulture);
var typeName = isGenericType ? y.TypeName.SubstringLastIndexOf(".").Replace(")", "") : y.TypeName.SubstringLastIndexOf(".");
var entityType = conceptual.Index_EntityTypes_Name[typeName];
y.EntityType = entityType;
entityType.EntityTypeMapping = y;
if (isGenericType)
{
entityType.GenericEntitySetMapping = y;
}
var storeEntitySet = storage.EntityContainer.Index_EntitySets_Name[y.MappingFragment.StoreEntitySetName];
storeEntitySet.EntitySetMapping = x;
y.MappingFragment.StoreEntitySet = storeEntitySet;
}
else
{
// FunctionMapping
}
});
var entityTypeMapping = x.EntityTypeMappings.Where(y => y.MappingFragment != null).ToList();
if (entityTypeMapping.Count > 1)
{
if (entityTypeMapping.Select(y => y.MappingFragment.StoreEntitySetName).Distinct().Count() == 1)
{
// TPH => All entity saved in the same table
entityTypeMapping.ForEach(y => y.EntityType.IsTPH = true);
x.ConceptualSet.IsTPH = true;
}
else if (!entityTypeMapping.Exists(y => y.TypeName.StartsWith("IsTypeOf(", StringComparison.InvariantCulture)))
{
// TPC => All most derived entity saved in their own table
entityTypeMapping.ForEach(y => y.EntityType.IsTPC = true);
x.ConceptualSet.IsTPC = true;
}
else
{
// TPT => All entity saved in their own table
entityTypeMapping.ForEach(y => y.EntityType.IsTPT = true);
x.ConceptualSet.IsTPT = true;
}
}
});
}
public void SqlNameTest()
{
var schema = new TableSchema("SqlNameTest");
var mapping = new SchemaMapping(schema);
Assert.AreEqual(mapping.SqlName, schema.Name);
Assert.IsNull(mapping.SqlSchemaName);
}
void AssertSchemaMapping(SchemaMapping mapping)
{
#if DEBUG
if (_debugHookNonEmptySelectCommand)
{
Debug.Assert(mapping != null && mapping.DataValues != null && mapping.DataTable != null, "Debug hook specifies that non-empty results are not expected");
}
#endif
}
public void NoCalculatedColumnsTest()
{
var schema = new TableSchema("NoCalculatedColumnsTest");
var cc = schema.Columns.AddCalculatedColumn <int>("Calculated", row => 4);
var mapping = new SchemaMapping(schema);
Assert.AreEqual(0, mapping.Columns.Count);
mapping.Columns.AddMapping(cc);
}
static StagedPayment()
{
#region Create Schema
Schema = new TypedSchema <StagedPayment>("StagedPayments");
Schema.PrimaryKey = StagedPaymentIdColumn = Schema.Columns.AddValueColumn("StagedPaymentId", typeof(Guid), null);
StagedPaymentIdColumn.Unique = true;
StagedPaymentIdColumn.AllowNulls = false;
StagedPersonColumn = Schema.Columns.AddForeignKey("StagedPerson", StagedPerson.Schema, "StagedPayments");
StagedPersonColumn.AllowNulls = false;
DateColumn = Schema.Columns.AddValueColumn("Date", typeof(DateTime), null);
DateColumn.AllowNulls = false;
MethodColumn = Schema.Columns.AddValueColumn("Method", typeof(String), null);
MethodColumn.AllowNulls = false;
CheckNumberColumn = Schema.Columns.AddValueColumn("CheckNumber", typeof(String), null);
CheckNumberColumn.AllowNulls = true;
AccountColumn = Schema.Columns.AddValueColumn("Account", typeof(String), null);
AccountColumn.AllowNulls = false;
AmountColumn = Schema.Columns.AddValueColumn("Amount", typeof(Decimal), null);
AmountColumn.AllowNulls = false;
CommentsColumn = Schema.Columns.AddValueColumn("Comments", typeof(String), null);
CommentsColumn.AllowNulls = true;
ExternalIdColumn = Schema.Columns.AddValueColumn("ExternalId", typeof(String), null);
ExternalIdColumn.AllowNulls = false;
CompanyColumn = Schema.Columns.AddValueColumn("Company", typeof(String), null);
CompanyColumn.AllowNulls = true;
#endregion
#region Create SchemaMapping
SchemaMapping = new SchemaMapping(Schema, false);
SchemaMapping.SqlName = "StagedPayments";
SchemaMapping.SqlSchemaName = "BillingMigration";
SchemaMapping.Columns.AddMapping(StagedPaymentIdColumn, "StagedPaymentId");
SchemaMapping.Columns.AddMapping(StagedPersonColumn, "StagedPersonId");
SchemaMapping.Columns.AddMapping(DateColumn, "Date");
SchemaMapping.Columns.AddMapping(MethodColumn, "Method");
SchemaMapping.Columns.AddMapping(CheckNumberColumn, "CheckNumber");
SchemaMapping.Columns.AddMapping(AccountColumn, "Account");
SchemaMapping.Columns.AddMapping(AmountColumn, "Amount");
SchemaMapping.Columns.AddMapping(CommentsColumn, "Comments");
SchemaMapping.Columns.AddMapping(ExternalIdColumn, "ExternalId");
SchemaMapping.Columns.AddMapping(CompanyColumn, "Company");
#endregion
SchemaMapping.SetPrimaryMapping(SchemaMapping);
}
public void Test_mapping_two_complex_types_with_complex_elements_to_duplicated_bcc()
{
var mappingFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_two_complex_types_with_complex_elements_to_duplicated_bcc\mapping.mfd");
var xsdFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_two_complex_types_with_complex_elements_to_duplicated_bcc\source.xsd");
SchemaMapping mappings = CreateSchemaMapping(mappingFileName, xsdFileName);
var textTypeToTextMapping = new ComplexTypeToCdtMapping("Text", "TextType",
new List <ElementMapping>
{
new AttributeOrSimpleElementToSupMapping(new SourceItem("Language", null, XsdObjectType.Attribute, null), supTextLanguage),
});
var austrianAddressTypeMapping = new ComplexTypeToAccMapping("AustrianAddress", "AustrianAddressType",
new List <ElementMapping>
{
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("CityName", null, XsdObjectType.Element, null), bccCityName, textTypeToTextMapping),
});
var indianAddressTypeMapping = new ComplexTypeToAccMapping("IndianAddress", "IndianAddressType",
new List <ElementMapping>
{
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("CityName", null, XsdObjectType.Element, null), bccCityName, textTypeToTextMapping),
});
var addressBookTypeMapping = new ComplexTypeToMaMapping("AddressBook", "AddressBookType",
new List <ElementMapping>
{
new AsmaMapping(new SourceItem("AustrianAddress", null, XsdObjectType.Element, null))
{
TargetMapping = austrianAddressTypeMapping
},
new AsmaMapping(new SourceItem("IndianAddress", null, XsdObjectType.Element, null))
{
TargetMapping = indianAddressTypeMapping
},
});
var expectedComplexTypeMappings = new List <IMapping>
{
textTypeToTextMapping,
austrianAddressTypeMapping,
indianAddressTypeMapping,
addressBookTypeMapping,
};
var expectedRootElementMapping = new AsmaMapping(new SourceItem("InternationalAddressBook", null, XsdObjectType.Element, null))
{
TargetMapping = addressBookTypeMapping
};
AssertMappings(mappings, expectedComplexTypeMappings, new List <SimpleTypeToCdtMapping>(), expectedRootElementMapping);
}
public void SetUp()
{
_dataTable = DataSourceBuilder.BuildSchemaTable(
new SchemaMappingColumn("StringProp", typeof(string), true),
new SchemaMappingColumn("IntProp", typeof(int), false),
new SchemaMappingColumn("DateTimeProp", typeof(DateTime), false)
);
_mapping = new SchemaMapping();
_mapping.Load(_dataTable);
}
private async Task <int> FillLoadDataRowChunkAsync(SchemaMapping mapping, int startRecord, int maxRecords)
{
DataReaderContainer dataReader = mapping.DataReader;
while (0 < startRecord)
{
if (!await dataReader.ReadAsync())
{
// there are no more rows on first resultset
return(0);
}
--startRecord;
}
int rowsAddedToDataSet = 0;
if (0 < maxRecords)
{
while ((rowsAddedToDataSet < maxRecords) && await dataReader.ReadAsync())
{
if (_hasFillErrorHandler)
{
try
{
await mapping.LoadDataRowWithClear();
rowsAddedToDataSet++;
}
catch (Exception e)
{
//
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
ADP.TraceExceptionForCapture(e);
OnFillErrorHandler(e, mapping.DataTable, mapping.DataValues);
}
}
else
{
await mapping.LoadDataRow();
rowsAddedToDataSet++;
}
}
// skip remaining rows of the first resultset
}
else
{
rowsAddedToDataSet = await FillLoadDataRowAsync(mapping);
}
return(rowsAddedToDataSet);
}
public void SortByName()
{
var entityMapper = MappingFactory.CreateEntityMappingFromAnnonations <NotNullEntity>();
var schemaTable = DataSourceBuilder.BuildSchemaTableFromEntityMapping(entityMapper);
var schemaMapping = new SchemaMapping();
schemaMapping.Load(schemaTable);
var columns = schemaMapping.Columns.ToArray();
SchemaMappingColumn.SortByName(columns, "FID", "FIntProp", "FLongProp");
Assert.AreEqual("FID", columns[0].ColumnName);
}
internal async Task <object> FillSchemaFromReaderAsync(DataSet dataset, DataTable datatable, SchemaType schemaType, string srcTable, DbDataReader dataReader)
{
DataTable[] dataTables = null;
int schemaCount = 0;
do
{
DataReaderContainer readerHandler = DataReaderContainer.Create(dataReader, ReturnProviderSpecificTypes);
AssertReaderHandleFieldCount(readerHandler);
if (0 >= readerHandler.FieldCount)
{
continue;
}
string tmp = null;
if (null != dataset)
{
tmp = DataAdapter.GetSourceTableName(srcTable, schemaCount);
schemaCount++; // don't increment if no SchemaTable ( a non-row returning result )
}
SchemaMapping mapping = new SchemaMapping(this, dataset, datatable, readerHandler, true, schemaType, tmp, false, null, null);
if (null != datatable)
{
// do not read remaining results in single DataTable case
return(mapping.DataTable);
}
else if (null != mapping.DataTable)
{
if (null == dataTables)
{
dataTables = new DataTable[1] {
mapping.DataTable
};
}
else
{
dataTables = DataAdapter.AddDataTableToArray(dataTables, mapping.DataTable);
}
}
} while (await dataReader.NextResultAsync()); // FillSchema does not capture errors for FillError event
object value = dataTables;
if ((null == value) && (null == datatable))
{ // WebData 101757
value = new DataTable[0];
}
return(value); // null if datatable had no results
}
public void NullValuesTest()
{
using (var connection = SqlProvider.OpenConnection())
connection.ExecuteNonQuery(@"
CREATE TABLE [NullableTest](
[ID] UNIQUEIDENTIFIER NOT NULL ROWGUIDCOL PRIMARY KEY DEFAULT(newid()),
[Integer] INTEGER NULL,
[String] NVARCHAR(1024) NULL,
[RowVersion] RowVersion
);");
var schema = new TableSchema("NullableTest");
schema.PrimaryKey = schema.Columns.AddValueColumn("ID", typeof(Guid), null);
schema.Columns.AddValueColumn("Integer", typeof(int?), null);
schema.Columns.AddValueColumn("String", typeof(string), null);
var mapping = new SchemaMapping(schema);
var table = new Table(schema);
var syncer = new TableSynchronizer(table, mapping, SqlProvider);
table.Rows.AddFromValues(Guid.NewGuid());
table.Rows.AddFromValues(Guid.NewGuid(), 4, null);
table.Rows.AddFromValues(Guid.NewGuid(), null, "4");
table.Rows.AddFromValues(Guid.NewGuid(), 4, "4");
syncer.WriteData();
var newTable = new Table(schema);
var newSyncer = new TableSynchronizer(newTable, mapping, SqlProvider);
newSyncer.ReadData();
AssertTablesEqual(table, newTable);
table.Rows[0]["Integer"] = 5;
table.Rows[0]["String"] = "5";
table.Rows[3]["Integer"] = null;
table.Rows[3]["String"] = null;
syncer.WriteData();
newTable = new Table(schema);
newSyncer = new TableSynchronizer(newTable, mapping, SqlProvider);
newSyncer.ReadData();
AssertTablesEqual(table, newTable);
syncer.ReadData();
AssertTablesEqual(newTable, table);
}
public void Test_mapping_with_semisemantic_loss()
{
var mappingFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_with_semisemantic_loss\mapping.mfd");
var xsdFileName = TestUtils.PathToTestResource(@"XSDImporterTest\mapping\SchemaMappingTests\mapping_with_semisemantic_loss\source.xsd");
SchemaMapping mappings = CreateSchemaMapping(mappingFileName, xsdFileName);
SimpleTypeToCdtMapping stringMapping = new SimpleTypeToCdtMapping("String", cdtText);
var expectedSimpleTypeMappings = new List <SimpleTypeToCdtMapping>
{
stringMapping,
};
var addressTypeMapping = new ComplexTypeToAccMapping("Address", "AddressType",
new List <ElementMapping>
{
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("StreetName", null, XsdObjectType.Element, null), bccCityName, stringMapping),
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("Town", null, XsdObjectType.Element, null), bccCityName, stringMapping),
});
var personTypeMapping = new ComplexTypeToAccMapping("Person", "PersonType",
new List <ElementMapping>
{
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("FirstName", null, XsdObjectType.Element, null), bccPartyName, stringMapping),
new AttributeOrSimpleElementOrComplexElementToBccMapping(new SourceItem("LastName", null, XsdObjectType.Element, null), bccPartyName, stringMapping),
new ComplexElementToAsccMapping(new SourceItem("HomeAddress", null, XsdObjectType.Element, null), asccPartyResidenceAddress)
{
TargetMapping = addressTypeMapping
},
new ComplexElementToAsccMapping(new SourceItem("WorkAddress", null, XsdObjectType.Element, null), asccPartyResidenceAddress)
{
TargetMapping = addressTypeMapping
},
});
var expectedComplexTypeMappings = new List <IMapping>
{
addressTypeMapping,
personTypeMapping
};
var expectedRootElementMapping = new AsmaMapping(new SourceItem("Person", null, XsdObjectType.Element, null))
{
TargetMapping = personTypeMapping
};
AssertMappings(mappings, expectedComplexTypeMappings, expectedSimpleTypeMappings, expectedRootElementMapping);
}
private bool StartImportSchema()
{
var importer = new MappingImporter(Model.MappingFiles, new[] { mappedSchemaFileSelector.FileName },
SelectedCcLibrary,
SelectedBLibrary, docLibraryNameTextBox.Text,
bieLibraryNameTextBox.Text,
bdtLibraryNameTextBox.Text, qualifierTextBox.Text,
rootElementNameTextBox.Text,
CctsRepository);
try
{
importer.ImportMapping();
}
catch (FileNotFoundException)
{
MessageBox.Show(@"The Schema file could not be openend!", Title, MessageBoxButtons.OK,
MessageBoxIcon.Error);
return(false);
}
catch (DirectoryNotFoundException)
{
MessageBox.Show(@"The Schema file could not be openend!", Title, MessageBoxButtons.OK,
MessageBoxIcon.Error);
return(false);
}
catch (MappingError me)
{
DialogResult errorResult =
MessageBox.Show(
@"An error occured while mapping the following element:" + me.Message +
@"You can edit the mapping file and click 'Retry' to re-start the import process!", Title,
MessageBoxButtons.RetryCancel, MessageBoxIcon.Error);
if (errorResult == System.Windows.Forms.DialogResult.Retry)
{
return(StartImportSchema());
}
return(false);
}
SchemaMapping schemaMapping = importer.mappings;
XmlSchema schema = XmlSchema.Read(XmlReader.Create(mappedSchemaFileSelector.FileName), null);
var xsltLogic = new XsltGenerator(schema.TargetNamespace, schemaMapping);
XmlDocument outputDocToCCl = xsltLogic.SetUpXsltToCClDocument();
var outputDocToSource = xsltLogic.SetUpXsltToSourceDocument();
outputDocToSource.Save(Path.Combine(@outputFolder.DirectoryName, "mappingToSource.xslt"));
outputDocToCCl.Save(Path.Combine(@outputFolder.DirectoryName, "mappingToCCl.xslt"));
return(true);
}
public void XmlPropertiesTest()
{
var schema = new TableSchema("XmlPropertiesTest");
var mapping = new SchemaMapping(schema);
var newMapping = SchemaMapping.FromXml(mapping.ToXml(), schema);
TestMapping(mapping);
mapping.SqlSchemaName = "ABC";
TestMapping(mapping);
mapping.SqlName = "DEF";
TestMapping(mapping);
}
static void AssertMappingsEqual(SchemaMapping expected, SchemaMapping actual)
{
Assert.AreEqual(expected.Schema, actual.Schema);
Assert.AreEqual(expected.SqlName, actual.SqlName);
Assert.AreEqual(expected.SqlSchemaName, actual.SqlSchemaName);
Assert.AreEqual(expected.Columns.Count, actual.Columns.Count);
for (int i = 0; i < expected.Columns.Count; i++)
{
ColumnMapping e = expected.Columns[i], a = actual.Columns[i];
Assert.AreEqual(e.Column, a.Column);
Assert.AreEqual(e.SqlName, a.SqlName);
}
Assert.AreEqual(expected.ToXml().ToString(), actual.ToXml().ToString());
}
public void ColumnsTest()
{
var schema = new TableSchema("ColumnsTest");
schema.Columns.AddValueColumn("Col1", typeof(int), 5);
schema.Columns.AddValueColumn("Col2", typeof(int), 5);
var cc = schema.Columns.AddCalculatedColumn <int>("Calculated", row => 4);
schema.Columns.AddValueColumn("Col4", typeof(int), 5);
var mapping = new SchemaMapping(schema);
Assert.AreEqual(3, mapping.Columns.Count);
Assert.IsNull(mapping.Columns[cc]);
Assert.AreEqual(schema.Columns.Last(), mapping.Columns[2].Column);
Assert.AreEqual(schema.Columns[1], mapping.Columns["Col2"].Column);
}
public void PrimaryKeyTest()
{
var schema = new TableSchema("PrimaryKeyTest");
schema.Columns.AddValueColumn("Col1", typeof(int), 5);
schema.PrimaryKey = schema.Columns.AddValueColumn("Col2", typeof(int), 5);
var cc = schema.Columns.AddCalculatedColumn <int>("Calculated", row => 4);
schema.Columns.AddValueColumn("Col4", typeof(int), 5);
var mapping = new SchemaMapping(schema);
Assert.AreEqual(3, mapping.Columns.Count);
Assert.AreEqual(schema.PrimaryKey, schema.Columns[1]);
Assert.AreEqual(mapping.PrimaryKey, mapping.Columns[1]);
Assert.AreEqual(mapping.PrimaryKey.Column, schema.PrimaryKey);
}
internal static void BuildMapping_FixTPH(SchemaMapping mapping, Schema conceptual, Schema storage)
{
conceptual.EntityTypes.Where(x => x.IsTPH && x.BaseType == null).ToList().ForEach(entity =>
{
// ADD generic scalar mapping
entity.GenericEntitySetMapping.MappingFragment.ScalarAccessors
//.Where(x => !x.AccessorPath.Contains(".")) // Why complex type was not added before?
.Where(x => !entity.EntityTypeMapping.MappingFragment.ScalarAccessors.Exists(y => y.AccessorPath == x.AccessorPath)).ToList().ForEach(x =>
entity.EntityTypeMapping.MappingFragment.ScalarAccessors.Add(new ScalarAccessorMapping
{
IsStorageMapped = true,
Type = x.Type,
AccessorPath = x.AccessorPath,
ColumnName = x.ColumnName,
IsComputed = x.IsComputed
}));
});
// FOR EACH TPH entity, ensure to add all column from bass class
foreach (var tphEntity in conceptual.EntityTypes.Where(x => x.IsTPH))
{
var baseEntity = tphEntity.BaseType;
while (baseEntity != null)
{
if (baseEntity.EntityTypeMapping != null)
{
var baseAccessors = baseEntity.EntityTypeMapping.MappingFragment.ScalarAccessors;
foreach (var accessor in baseAccessors)
{
// CHECK if that has not already be added then add the key
if (!tphEntity.EntityTypeMapping.MappingFragment.ScalarAccessors.Exists(x => x.ColumnName == accessor.ColumnName))
{
tphEntity.EntityTypeMapping.MappingFragment.ScalarAccessors.Add(accessor);
}
}
}
baseEntity = baseEntity.BaseType;
}
}
}
///<summary>Ensures that a set of tables are loaded in the DataContext.</summary>
public static void LoadTables(IEnumerable <TableSchema> schemas)
{
var allSchemas = new HashSet <TableSchema>();
foreach (var schema in schemas.Where(s => Current.DataContext.Tables[s] == null))
{
allSchemas.Add(schema);
allSchemas.UnionWith(schema.GetDependencies());
}
if (allSchemas.Count == 0)
{
return; //All of the tables are already loaded
}
var tables = allSchemas
.SortDependencies()
.Except(Current.DataContext.Tables.Select(t => t.Schema)) //Must be called after SortDependencies, since sorting requires all dependencies
.Select(ts => ts.CreateTable())
.ToList();
//Calculated columns can use child rows. I must add the
//tables in reverse order to allow the RowDependencies
//to register handlers for the child tables.
tables.Reverse();
tables.ForEach(Current.DataContext.Tables.AddTable);
var syncers = tables.ConvertAll(t => new TableSynchronizer(t, SchemaMapping.GetPrimaryMapping(t.Schema), Current.SyncContext.SqlProvider));
syncers.ForEach(Current.SyncContext.Tables.Add);
var threadContext = SynchronizationContext.Current;
ProgressWorker.Execute(ui => {
if (Current.HasDataChanged)
{
Current.SyncContext.WriteData(ui); //I must save before loading in case a parent row was deleted. (The DB is expected to cascade)
}
ui.Maximum = -1;
ui.Caption = "Loading " + tables.Join(", ", t => t.Schema.Name);
Current.SyncContext.ReadData(threadContext); //I must refresh everything to pick up potential changes in parent rows
}, false);
}
internal static void BuildMapping_EntitySetMapping(SchemaMapping mapping, Schema conceptual, Schema storage)
{
mapping.EntityContainerMapping.EntitySetMappings.ForEach(entitySetMapping =>
{
entitySetMapping.EntityTypeMappings.Where(x => x.MappingFragment != null).ToList().ForEach(entityTypeMapping =>
{
var mappingFragment = entityTypeMapping.MappingFragment;
// ADD scalar accessor for properties
mappingFragment.ScalarProperties.ForEach(x =>
{
Type type = null;
if (entityTypeMapping.EntityType != null)
{
type = GetPropertyType_Reccursive(entityTypeMapping.EntityType, x.Name);
}
var property = GetProperty_Reccursive(entityTypeMapping.EntityType, x.Name);
mappingFragment.ScalarAccessors.Add(new ScalarAccessorMapping
{
IsStorageMapped = true,
Type = type,
AccessorPath = x.Name,
ColumnName = x.ColumnName,
IsComputed = property.IsComputed,
IsConcurrency = property.IsConcurrency,
IsIdentity = property.StoreGeneratedPattern == "Identity"
});
});
// ADD scalar accessor from conditions
mappingFragment.Conditions.ForEach(x => mappingFragment.ScalarAccessors.Add(new ScalarAccessorMapping
{
IsStorageMapped = true,
Type = typeof(string),
AccessorPath = x.ColumnName,
ConstantValue = x.Value,
ColumnName = x.ColumnName
}));
});
});
}
