/// <summary>
/// Generates required data for a OneToMany relationship without embedded documents
/// </summary>
/// <returns></returns>
public static RequiredDataContainer OneToManyNotEmbedded()
{
// Create ER Stuff
Entity Person = new Entity("Person");
Person.AddAttribute("personId");
Person.AddAttribute("name");
Entity Car = new Entity("Car");
Car.AddAttribute("carId");
Car.AddAttribute("name");
Car.AddAttribute("year");
Car.AddAttribute("personId");
Relationship Drives = new Relationship("Drives");
Drives.AddRelationshipEnd(new RelationshipEnd(Person));
Drives.AddRelationshipEnd(new RelationshipEnd(Car));
ERModel Model = new ERModel("PersonCarModel", new List <BaseERElement> {
Person, Car, Drives
});
// Create MongoDB schema
MongoDBCollection PersonCollection = new MongoDBCollection("Person");
PersonCollection.DocumentSchema.AddAttribute("_id");
PersonCollection.DocumentSchema.AddAttribute("name");
MongoDBCollection CarCollection = new MongoDBCollection("Car");
CarCollection.DocumentSchema.AddAttribute("_id");
CarCollection.DocumentSchema.AddAttribute("name");
CarCollection.DocumentSchema.AddAttribute("year");
CarCollection.DocumentSchema.AddAttribute("personId");
MongoSchema Schema = new MongoSchema("PersonCarSchema", new List <MongoDBCollection> {
PersonCollection, CarCollection
});
// Create Map
MapRule PersonRule = new MapRule(Model.FindByName("Person"), Schema.FindByName("Person"));
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
MapRule CarRule = new MapRule(Model.FindByName("Car"), Schema.FindByName("Car"));
CarRule.AddRule("carId", "_id");
CarRule.AddRule("name", "name");
CarRule.AddRule("year", "year");
CarRule.AddRule("personId", "personId");
ModelMapping Map = new ModelMapping("PersonCarMap", new List <MapRule> {
PersonRule, CarRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Generate a simple model
/// </summary>
/// <returns></returns>
public static RequiredDataContainer SimpleModel()
{
Entity Person = new Entity("Person");
Person.AddAttributes("personId", "name", "age");
ERModel Model = new ERModel("ProjectModel", new List <BaseERElement> {
Person
});
MongoDBCollection PersonCol = new MongoDBCollection("Person");
PersonCol.AddAttributes("_id", "name", "age");
MongoSchema Schema = new MongoSchema("PersonSchema", new List <MongoDBCollection> {
PersonCol
});
MapRule PersonRule = new MapRule(Person, PersonCol);
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
PersonRule.AddRule("age", "age");
ModelMapping Map = new ModelMapping("PersonMap", new List <MapRule> {
PersonRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Test data for virtual maps
/// </summary>
/// <returns></returns>
public static RequiredDataContainer VirtualMapModel()
{
// ER Stuff
Entity Person = new Entity("Person");
Person.AddAttributes("personId", "name", "age");
Person.SetIdentifier("personId");
Entity Pet = new Entity("Pet");
Pet.AddAttributes("petId", "name", "type");
Pet.SetIdentifier("petId");
Relationship HasPet = new Relationship("HasPet");
HasPet.AddRelationshipEnd(new RelationshipEnd(Person));
HasPet.AddRelationshipEnd(new RelationshipEnd(Pet));
ERModel Model = new ERModel("Model", new List <BaseERElement>()
{
Person, Pet, HasPet
});
MongoDBCollection PersonCol = new MongoDBCollection("Person");
PersonCol.AddAttributes("_id", "name", "age");
MongoDBCollection PetCol = new MongoDBCollection("Pet");
PetCol.AddAttributes("_id", "name", "type", "ownerId");
MongoSchema Schema = new MongoSchema("Schema", new List <MongoDBCollection>()
{
PersonCol, PetCol
});
MapRule PersonRules = new MapRule(Person, PersonCol);
PersonRules.AddRule("personId", "_id");
PersonRules.AddRule("name", "name");
PersonRules.AddRule("age", "age");
MapRule PetRules = new MapRule(Pet, PetCol);
PetRules.AddRule("petId", "_id");
PetRules.AddRule("name", "name");
PetRules.AddRule("type", "type");
MapRule PersonPetRule = new MapRule(Person, PetCol, false);
PersonPetRule.AddRule("personId", "ownerId");
ModelMapping Map = new ModelMapping("Map", new List <MapRule>()
{
PersonRules, PetRules, PersonPetRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Generates required data to test a One To Many relationship
/// joining one entity while the left side entity is embedded into another
/// </summary>
/// <returns></returns>
public static RequiredDataContainer OneToManyLeftSideEmbedded()
{
Entity Car = new Entity("Car");
Car.AddAttribute("carId");
Car.AddAttribute("model");
Entity Insurance = new Entity("Insurance");
Insurance.AddAttribute("insuranceId");
Insurance.AddAttribute("name");
Insurance.AddAttribute("value");
Insurance.AddAttribute("carId");
Relationship HasInsurance = new Relationship("HasInsurance");
HasInsurance.AddRelationshipEnd(new RelationshipEnd(Car));
HasInsurance.AddRelationshipEnd(new RelationshipEnd(Insurance));
ERModel Model = new ERModel("CarInsuranceModel", new List <BaseERElement> {
Car, Insurance, HasInsurance
});
MongoDBCollection CarCol = new MongoDBCollection("Car");
CarCol.DocumentSchema.AddAttribute("carId");
CarCol.DocumentSchema.AddAttribute("model");
MongoDBCollection InsCol = new MongoDBCollection("Insurance");
InsCol.DocumentSchema.AddAttribute("_id");
InsCol.DocumentSchema.AddAttribute("name");
InsCol.DocumentSchema.AddAttribute("value");
InsCol.DocumentSchema.AddAttribute("carId");
MongoSchema Schema = new MongoSchema("CarInsuranceSchema", new List <MongoDBCollection> {
CarCol, InsCol
});
MapRule CarRule = new MapRule(Car, CarCol);
CarRule.AddRule("carId", "car.carId");
CarRule.AddRule("model", "car.model");
MapRule InsRule = new MapRule(Insurance, InsCol);
InsRule.AddRule("insuranceId", "_id");
InsRule.AddRule("name", "name");
InsRule.AddRule("value", "value");
InsRule.AddRule("carId", "carId");
ModelMapping Map = new ModelMapping("CarInsuranceMap", new List <MapRule> {
CarRule, InsRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Generate data with a computed entity
/// </summary>
/// <returns></returns>
public static RequiredDataContainer ComputedEntityData()
{
Entity Person = new Entity("Person");
Person.AddAttributes("personId", "name");
Person.SetIdentifier("personId");
Entity Car = new Entity("Car");
Car.AddAttributes("carId", "model", "year");
Car.SetIdentifier("carId");
Entity Garage = new Entity("Garage");
Garage.AddAttributes("garageId", "name");
Garage.SetIdentifier("garageId");
Entity Supplier = new Entity("Supplier");
Supplier.AddAttributes("supplierId", "name");
Supplier.SetIdentifier("supplierId");
Entity Insurance = new Entity("Insurance");
Insurance.AddAttributes("insuranceId", "name", "value");
Insurance.SetIdentifier("insuranceId");
Entity Manufacturer = new Entity("Manufacturer");
Manufacturer.AddAttributes("manufacturerId", "name");
Manufacturer.SetIdentifier("manufacturerId");
Relationship Owns = new Relationship("Owns");
Owns.AddAttributes("ownsId");
Owns.AddRelationshipEnd(new RelationshipEnd(Car));
Owns.AddRelationshipEnd(new RelationshipEnd(Person));
Owns.AddRelationshipEnd(new RelationshipEnd(Insurance));
Relationship Repaired = new Relationship("Repaired");
Repaired.AddAttributes("repairedId", "repaired");
Repaired.AddRelationshipEnd(new RelationshipEnd(Car));
Repaired.AddRelationshipEnd(new RelationshipEnd(Garage));
Repaired.AddRelationshipEnd(new RelationshipEnd(Supplier));
Relationship ManufacturedBy = new Relationship("ManufacturedBy");
ManufacturedBy.AddRelationshipEnd(new RelationshipEnd(Car));
ManufacturedBy.AddRelationshipEnd(new RelationshipEnd(Manufacturer));
ERModel Model = new ERModel("ERModel", new List <BaseERElement> {
Person, Car, Garage, Repaired, Supplier, Insurance, Owns, Manufacturer, ManufacturedBy
});
// Mongo Schema
MongoDBCollection PersonCol = new MongoDBCollection("Person");
PersonCol.AddAttributes("_id", "name");
MongoDBCollection CarCol = new MongoDBCollection("Car");
CarCol.AddAttributes("_id", "model", "year", "manufacturerId");
MongoDBCollection GarageCol = new MongoDBCollection("Garage");
GarageCol.AddAttributes("_id", "name");
MongoDBCollection SupplierCol = new MongoDBCollection("Supplier");
SupplierCol.AddAttributes("_id", "name");
MongoDBCollection RepairedCol = new MongoDBCollection("Repaired");
RepairedCol.AddAttributes("_id", "carId", "garageId", "supplierId", "repaired");
MongoDBCollection InsuranceCol = new MongoDBCollection("Insurance");
InsuranceCol.AddAttributes("_id", "name", "value");
MongoDBCollection OwnsCol = new MongoDBCollection("Owns");
OwnsCol.AddAttributes("_id", "personId", "carId", "insuranceId");
MongoDBCollection ManufacturerCol = new MongoDBCollection("Manufacturer");
ManufacturerCol.AddAttributes("_id", "name");
MongoSchema Schema = new MongoSchema("Schema", new List <MongoDBCollection> {
PersonCol, CarCol, GarageCol, RepairedCol, SupplierCol, InsuranceCol, OwnsCol, ManufacturerCol
});
// Map Rules
MapRule PersonRule = new MapRule(Person, PersonCol);
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
MapRule CarRule = new MapRule(Car, CarCol);
CarRule.AddRule("carId", "_id");
CarRule.AddRule("model", "model");
CarRule.AddRule("year", "year");
MapRule GarageRule = new MapRule(Garage, GarageCol);
GarageRule.AddRule("garageId", "_id");
GarageRule.AddRule("name", "name");
MapRule SupplierRule = new MapRule(Supplier, SupplierCol);
SupplierRule.AddRule("supplierId", "_id");
SupplierRule.AddRule("name", "name");
MapRule RepairedRule = new MapRule(Repaired, RepairedCol);
RepairedRule.AddRule("repairedId", "_id");
RepairedRule.AddRule("repaired", "repaired");
MapRule InsuranceRule = new MapRule(Insurance, InsuranceCol);
InsuranceRule.AddRule("insuranceId", "_id");
InsuranceRule.AddRule("name", "name");
InsuranceRule.AddRule("value", "value");
MapRule OwnsRule = new MapRule(Owns, OwnsCol);
OwnsRule.AddRule("ownsId", "_id");
MapRule ManufacturerRule = new MapRule(Manufacturer, ManufacturerCol);
ManufacturerRule.AddRule("manufacturerId", "_id");
ManufacturerRule.AddRule("name", "name");
MapRule PersonOwnsRule = new MapRule(Person, OwnsCol, false);
PersonOwnsRule.AddRule("personId", "personId");
MapRule CarOwnsRule = new MapRule(Car, OwnsCol, false);
CarOwnsRule.AddRule("carId", "carId");
MapRule InsuranceOwnsRule = new MapRule(Insurance, OwnsCol, false);
InsuranceOwnsRule.AddRule("insuranceId", "insuranceId");
MapRule CarRepairedRule = new MapRule(Car, RepairedCol, false);
CarRepairedRule.AddRule("carId", "carId");
MapRule GarageRepairedRule = new MapRule(Garage, RepairedCol, false);
GarageRepairedRule.AddRule("garageId", "garageId");
MapRule SupplierRepairedRule = new MapRule(Supplier, RepairedCol, false);
SupplierRepairedRule.AddRule("supplierId", "supplierId");
MapRule ManufacturerCarRule = new MapRule(Manufacturer, CarCol, false);
ManufacturerCarRule.AddRule("manufacturerId", "manufacturerId");
ModelMapping Map = new ModelMapping("Map", new List <MapRule> {
PersonRule, CarRule, GarageRule, RepairedRule, SupplierRule, InsuranceRule, OwnsRule, ManufacturerRule, PersonOwnsRule, CarOwnsRule, InsuranceOwnsRule, CarRepairedRule, GarageRepairedRule, SupplierRepairedRule, ManufacturerCarRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Creates a MongoDBSchema and Mapping the is a 1-1 map with the ER model
/// </summary>
/// <returns></returns>
public static RequiredDataContainer MapEntitiesToCollections()
{
// Create Schema
MongoDBCollection UserCol = new MongoDBCollection("User");
UserCol.AddAttributes("_id", "user_name", "user_email", "user_access", "user_newsletter");
MongoDBCollection ProductCol = new MongoDBCollection("Product");
ProductCol.AddAttributes("_id", "product_title", "product_description", "product_short_description", "product_url",
"product_category_id", "product_store_id", "product_user_id", "product_published", "product_image");
MongoDBCollection CategoryCol = new MongoDBCollection("Category");
CategoryCol.AddAttributes("_id", "category_name");
MongoDBCollection StoreCol = new MongoDBCollection("Store");
StoreCol.AddAttributes("_id", "store_name", "store_logo");
MongoSchema Schema = new MongoSchema("CMSSchema", new List <MongoDBCollection>()
{
UserCol, ProductCol,
StoreCol, CategoryCol
});
// Retrieve ER Model
ERModel Model = CreateERModel();
// Build Mapping
Entity User = (Entity)Model.FindByName("User");
MapRule UserRules = new MapRule(User, UserCol);
UserRules.AddRule("user_id", "_id");
UserRules.AddRule("user_name", "user_name");
UserRules.AddRule("user_email", "user_email");
UserRules.AddRule("user_access", "user_access");
UserRules.AddRule("user_newsletter", "user_newsletter");
Entity Product = (Entity)Model.FindByName("Product");
MapRule ProductRules = new MapRule(Product, ProductCol);
ProductRules.AddRule("product_id", "_id");
ProductRules.AddRule("product_title", "product_title");
ProductRules.AddRule("product_description", "product_description");
ProductRules.AddRule("product_short_description", "product_short_description");
ProductRules.AddRule("product_url", "product_url");
ProductRules.AddRule("product_category_id", "product_category_id");
ProductRules.AddRule("product_store_id", "product_store_id");
ProductRules.AddRule("product_user_id", "product_user_id");
ProductRules.AddRule("product_published", "product_published");
ProductRules.AddRule("product_image", "product_image");
Entity Category = (Entity)Model.FindByName("Category");
MapRule CategoryRules = new MapRule(Category, CategoryCol);
CategoryRules.AddRule("category_id", "_id");
CategoryRules.AddRule("category_name", "category_name");
Entity Store = (Entity)Model.FindByName("Store");
MapRule StoreRules = new MapRule(Store, StoreCol);
StoreRules.AddRule("store_id", "_id");
StoreRules.AddRule("store_name", "store_name");
StoreRules.AddRule("store_logo", "store_logo");
ModelMapping Map = new ModelMapping("CMSMap11", new List <MapRule>()
{
UserRules,
ProductRules, CategoryRules, StoreRules
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Generates required data to test a One to One relationship
/// joining multiple entities with relationship attribute and multiple root attributes
/// </summary>
/// <returns></returns>
public static RequiredDataContainer OneToOneRelationshipMultipleRootAttributes()
{
// Create ER Stuff
Entity Person = new Entity("Person");
Person.AddAttribute("personId", true);
Person.AddAttribute("name");
Person.AddAttribute("insuranceId");
Entity Car = new Entity("Car");
Car.AddAttribute("name");
Car.AddAttribute("year");
Car.AddAttribute("engine");
Car.AddAttribute("fuel");
Entity Insurance = new Entity("Insurance");
Insurance.AddAttribute("insuranceId", true);
Insurance.AddAttribute("name");
Relationship HasInsurance = new Relationship("HasInsurance");
HasInsurance.AddAttribute("insuranceValue");
HasInsurance.AddRelationshipEnd(new RelationshipEnd(Person));
HasInsurance.AddRelationshipEnd(new RelationshipEnd(Car));
HasInsurance.AddRelationshipEnd(new RelationshipEnd(Insurance));
ERModel Model = new ERModel("PersonCarModel", new List <BaseERElement> {
Person, Car, HasInsurance, Insurance
});
// Create MongoDB schema
MongoDBCollection PersonCollection = new MongoDBCollection("Person");
PersonCollection.DocumentSchema.AddAttribute("_id");
PersonCollection.DocumentSchema.AddAttribute("name");
PersonCollection.DocumentSchema.AddAttribute("car.name");
PersonCollection.DocumentSchema.AddAttribute("car.year");
PersonCollection.DocumentSchema.AddAttribute("carDetails.engine");
PersonCollection.DocumentSchema.AddAttribute("CarDetails.fuel");
PersonCollection.DocumentSchema.AddAttribute("insuranceId");
PersonCollection.DocumentSchema.AddAttribute("insuranceValue");
MongoDBCollection InsuranceCollection = new MongoDBCollection("Insurance");
InsuranceCollection.DocumentSchema.AddAttribute("_id");
InsuranceCollection.DocumentSchema.AddAttribute("name");
MongoSchema Schema = new MongoSchema("PersonCarSchema", new List <MongoDBCollection> {
PersonCollection, InsuranceCollection
});
// Create Map
MapRule PersonRule = new MapRule(Model.FindByName("Person"), Schema.FindByName("Person"));
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
PersonRule.AddRule("carId", "carId");
PersonRule.AddRule("insuranceId", "insuranceId");
MapRule CarRule = new MapRule(Model.FindByName("Car"), Schema.FindByName("Person"), false);
CarRule.AddRule("name", "car.name");
CarRule.AddRule("year", "car.year");
CarRule.AddRule("engine", "carDetails.engine");
CarRule.AddRule("fuel", "carDetails.fuel");
MapRule InsuranceRule = new MapRule(Model.FindByName("Insurance"), Schema.FindByName("Insurance"));
InsuranceRule.AddRule("insuranceId", "_id");
InsuranceRule.AddRule("name", "name");
MapRule InsurancePersonRule = new MapRule(Model.FindByName("Insurance"), Schema.FindByName("Person"), false);
InsurancePersonRule.AddRule("insuranceId", "insuranceId");
MapRule RelationshipRule = new MapRule(Model.FindByName("HasInsurance"), Schema.FindByName("Person"), false);
RelationshipRule.AddRule("insuranceValue", "insuranceValue");
ModelMapping Map = new ModelMapping("PersonCarMap", new List <MapRule> {
PersonRule, CarRule, InsuranceRule, RelationshipRule, InsurancePersonRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Generates data to test a query in which the target entity is embedded in the middle collection
/// </summary>
/// <returns></returns>
public static RequiredDataContainer ManyToManyEmbeddedTarget()
{
// ER Model
Entity Person = new Entity("Person");
Person.AddAttribute("personId", true);
Person.AddAttributes("name", "age");
Entity Car = new Entity("Car");
Car.AddAttribute("carId", true);
Car.AddAttributes("model", "year");
Relationship Drives = new Relationship("Drives");
Drives.AddAttribute("something");
Drives.AddRelationshipEnd(new RelationshipEnd(Person));
Drives.AddRelationshipEnd(new RelationshipEnd(Car));
ERModel Model = new ERModel("Model", new List <BaseERElement>()
{
Person, Car, Drives
});
// Mongo Schema
MongoDBCollection PersonCol = new MongoDBCollection("Person");
PersonCol.AddAttributes("_id", "name", "age");
MongoDBCollection DrivesCol = new MongoDBCollection("Drives");
DrivesCol.AddAttributes("_id", "something", "car.carId", "car.model", "car.year");
MongoSchema Schema = new MongoSchema("Schema", new List <MongoDBCollection>()
{
PersonCol, DrivesCol
});
// Map
MapRule PersonRule = new MapRule(Person, PersonCol);
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
PersonRule.AddRule("age", "age");
MapRule CarRule = new MapRule(Car, DrivesCol, false);
CarRule.AddRule("carId", "car.carId");
CarRule.AddRule("model", "car.model");
CarRule.AddRule("year", "car.year");
MapRule DrivesRule = new MapRule(Drives, DrivesCol);
DrivesRule.AddRule("something", "something");
MapRule PersonDrivesRule = new MapRule(Person, DrivesCol, false);
PersonDrivesRule.AddRule("personId", "personId");
ModelMapping Map = new ModelMapping("Map", new List <MapRule>()
{
PersonRule, CarRule, DrivesRule, PersonDrivesRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Generates data to test a many to many relationship join with multiple entities
/// and relationship attributes
/// </summary>
/// <returns></returns>
public static RequiredDataContainer ManyToManyRelationshipAttributeMultipleEntities()
{
Entity Person = new Entity("Person");
Person.AddAttribute("personId", true);
Person.AddAttribute("name");
Entity Car = new Entity("Car");
Car.AddAttribute("carId", true);
Car.AddAttribute("name");
Car.AddAttribute("year");
Entity InsCompany = new Entity("InsCompany");
InsCompany.AddAttribute("companyId", true);
InsCompany.AddAttribute("name");
Relationship Insurance = new Relationship("Insurance");
Insurance.AddAttribute("insuranceId");
Insurance.AddAttribute("insuranceValue");
Insurance.AddAttribute("aRandomValue");
Insurance.AddRelationshipEnd(new RelationshipEnd(Person));
Insurance.AddRelationshipEnd(new RelationshipEnd(Car));
Insurance.AddRelationshipEnd(new RelationshipEnd(InsCompany));
ERModel Model = new ERModel("PersonCar", new List <BaseERElement> {
Person, Car, Insurance, InsCompany
});
// MongoDB Schema
MongoDBCollection PersonCol = new MongoDBCollection("Person");
PersonCol.DocumentSchema.AddAttribute("_id");
PersonCol.DocumentSchema.AddAttribute("name");
MongoDBCollection CarCol = new MongoDBCollection("Car");
CarCol.DocumentSchema.AddAttribute("_id");
CarCol.DocumentSchema.AddAttribute("name");
CarCol.DocumentSchema.AddAttribute("year");
MongoDBCollection InsuranceCol = new MongoDBCollection("Insurance");
InsuranceCol.DocumentSchema.AddAttribute("_id");
InsuranceCol.DocumentSchema.AddAttribute("personId");
InsuranceCol.DocumentSchema.AddAttribute("carId");
InsuranceCol.DocumentSchema.AddAttribute("companyId");
InsuranceCol.DocumentSchema.AddAttribute("insuranceValue");
InsuranceCol.DocumentSchema.AddAttribute("aRandomValue");
MongoDBCollection InsCompanyCol = new MongoDBCollection("InsCompany");
InsCompanyCol.DocumentSchema.AddAttribute("_id");
InsCompanyCol.DocumentSchema.AddAttribute("name");
MongoSchema DBSchema = new MongoSchema("PersonCarSchema",
new List <MongoDBCollection> {
PersonCol, CarCol, InsuranceCol, InsCompanyCol
});
// Map
MapRule PersonRule = new MapRule(Person, PersonCol);
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
MapRule CarRule = new MapRule(Car, CarCol);
CarRule.AddRule("carId", "_id");
CarRule.AddRule("name", "name");
CarRule.AddRule("year", "year");
MapRule InsuranceRule = new MapRule(Insurance, InsuranceCol);
InsuranceRule.AddRule("insuranceId", "_id");
InsuranceRule.AddRule("insuranceValue", "insuranceValue");
InsuranceRule.AddRule("aRandomValue", "aRandomValue");
MapRule InsCompanyRule = new MapRule(InsCompany, InsCompanyCol);
InsCompanyRule.AddRule("companyId", "_id");
InsCompanyRule.AddRule("name", "name");
MapRule PersonInsuranceRule = new MapRule(Person, InsuranceCol, false);
PersonInsuranceRule.AddRule("personId", "personId");
MapRule CarInsuranceRule = new MapRule(Car, InsuranceCol, false);
CarInsuranceRule.AddRule("carId", "carId");
MapRule InsCompanyInsuranceRule = new MapRule(InsCompany, InsuranceCol, false);
InsCompanyInsuranceRule.AddRule("companyId", "companyId");
ModelMapping Map = new ModelMapping("PersonCarMap", new List <MapRule> {
PersonRule,
CarRule, InsuranceRule, InsCompanyRule, PersonInsuranceRule, CarInsuranceRule, InsCompanyInsuranceRule
});
return(new RequiredDataContainer(Model, DBSchema, Map));
}
public static DataContainer CreateDataContainer()
{
Entity Person = new Entity("Person");
Person.AddAttribute("personId", true);
Person.AddAttribute("name");
Entity Car = new Entity("Car");
Car.AddAttribute("carId", true);
Car.AddAttributes("plate", "color");
Relationship Drives = new Relationship("Drives");
Drives.AddAttribute("note");
Drives.AddRelationshipEnd(new RelationshipEnd(Person));
Drives.AddRelationshipEnd(new RelationshipEnd(Car));
ERModel Model = new ERModel("Model", new List <BaseERElement>()
{
Person, Car, Drives
});
MongoDBCollection PersonCol = new MongoDBCollection("Person");
PersonCol.AddAttributes("_id", "name", "cars_multivalued_.id", "cars_multivalued_.note");
MongoDBCollection CarCol = new MongoDBCollection("Car");
CarCol.AddAttributes("_id", "plate", "color");
MongoSchema Schema = new MongoSchema("Schema", new List <MongoDBCollection>()
{
PersonCol, CarCol
});
MapRule PersonRule = new MapRule(Person, PersonCol);
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
MapRule CarRule = new MapRule(Car, CarCol);
CarRule.AddRule("carId", "_id");
CarRule.AddRule("plate", "plate");
CarRule.AddRule("color", "color");
MapRule CarPersonRule = new MapRule(Car, PersonCol, false);
CarPersonRule.AddRule("carId", "cars_multivalued_.id");
MapRule DrivesPersonRule = new MapRule(Drives, PersonCol, false);
DrivesPersonRule.AddRule("note", "cars_multivalued_.note");
ModelMapping Map = new ModelMapping("Map", new List <MapRule>()
{
PersonRule, CarRule, CarPersonRule, DrivesPersonRule
});
return(new DataContainer(Model, Schema, Map));
}
/// <summary>
/// Maps entities to collection and return all data (ERModel, MongoSchema and ModelMapping)
/// </summary>
/// <returns></returns>
public static RequiredDataContainer MapEntitiesToCollections()
{
// Create schema
MongoDBCollection UserCol = new MongoDBCollection("User");
UserCol.AddAttributes("_id", "UserName", "UserEmail");
MongoDBCollection ProductCol = new MongoDBCollection("Product");
ProductCol.AddAttributes("_id", "Title", "Description", "CategoryID", "StoreID", "UserID");
MongoDBCollection CategoryCol = new MongoDBCollection("Category");
CategoryCol.AddAttributes("_id", "CategoryName");
MongoDBCollection StoreCol = new MongoDBCollection("Store");
StoreCol.AddAttributes("_id", "StoreName");
MongoSchema Schema = new MongoSchema("CMSSchema", new List <MongoDBCollection>()
{
UserCol, ProductCol,
StoreCol, CategoryCol
});
// Retrieve ER Model
ERModel Model = GetERModel();
// Build mapping
Entity User = (Entity)Model.FindByName("User");
MapRule UserRules = new MapRule(User, UserCol);
UserRules.AddRule("UserID", "_id");
UserRules.AddRule("UserName", "UserName");
UserRules.AddRule("UserEmail", "UserEmail");
Entity Product = (Entity)Model.FindByName("Product");
MapRule ProductRules = new MapRule(Product, ProductCol);
ProductRules.AddRule("ProductID", "_id");
ProductRules.AddRule("Title", "Title");
ProductRules.AddRule("Description", "Description");
Entity Category = (Entity)Model.FindByName("Category");
MapRule CategoryRules = new MapRule(Category, CategoryCol);
CategoryRules.AddRule("CategoryID", "_id");
CategoryRules.AddRule("CategoryName", "CategoryName");
Entity Store = (Entity)Model.FindByName("Store");
MapRule StoreRules = new MapRule(Store, StoreCol);
StoreRules.AddRule("StoreID", "_id");
StoreRules.AddRule("StoreName", "StoreName");
MapRule UserProductRule = new MapRule(User, ProductCol, false);
UserProductRule.AddRule("UserID", "UserID");
MapRule StoreProductRule = new MapRule(Store, ProductCol, false);
StoreProductRule.AddRule("StoreID", "StoreID");
MapRule CategoryProductRule = new MapRule(Category, ProductCol, false);
CategoryProductRule.AddRule("CategoryID", "CategoryID");
ModelMapping Map = new ModelMapping("CMSMap11", new List <MapRule>()
{
UserRules,
ProductRules, CategoryRules, StoreRules, UserProductRule, StoreProductRule, CategoryProductRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
/// <summary>
/// Data for a computed entity test starting from a one to many relationship
/// </summary>
/// <returns></returns>
public static RequiredDataContainer OneToManyComputedEntity()
{
Entity Person = new Entity("Person");
Person.AddAttributes("personId", "name", "insuranceId");
Entity Car = new Entity("Car");
Car.AddAttributes("carId", "model", "year", "driverId");
Entity Garage = new Entity("Garage");
Garage.AddAttributes("garageId", "name");
Entity Supplier = new Entity("Supplier");
Supplier.AddAttributes("supplierId", "name");
Entity Insurance = new Entity("Insurance");
Insurance.AddAttributes("insuranceId", "name", "value");
Relationship Drives = new Relationship("Drives");
Drives.AddRelationshipEnd(new RelationshipEnd(Person));
Drives.AddRelationshipEnd(new RelationshipEnd(Car));
Relationship Repaired = new Relationship("Repaired");
Repaired.AddAttributes("repairedId", "carId", "garageId", "supplierId", "repaired");
Repaired.AddRelationshipEnd(new RelationshipEnd(Car));
Repaired.AddRelationshipEnd(new RelationshipEnd(Garage));
Repaired.AddRelationshipEnd(new RelationshipEnd(Supplier));;
Relationship HasInsurance = new Relationship("HasInsurance");
HasInsurance.AddRelationshipEnd(new RelationshipEnd(Person));
HasInsurance.AddRelationshipEnd(new RelationshipEnd(Insurance));
ERModel Model = new ERModel("ERModel", new List <BaseERElement> {
Person, Car, Garage, Drives, Repaired, Supplier, Insurance, HasInsurance
});
// Mongo Schema
MongoDBCollection PersonCol = new MongoDBCollection("Person");
PersonCol.AddAttributes("_id", "name", "insuranceId");
MongoDBCollection CarCol = new MongoDBCollection("Car");
CarCol.AddAttributes("_id", "model", "year", "driverId");
MongoDBCollection GarageCol = new MongoDBCollection("Garage");
GarageCol.AddAttributes("_id", "name");
MongoDBCollection SupplierCol = new MongoDBCollection("Supplier");
SupplierCol.AddAttributes("_id", "name");
MongoDBCollection RepairedCol = new MongoDBCollection("Repaired");
RepairedCol.AddAttributes("_id", "carId", "garageId", "supplierId", "repaired");
MongoDBCollection InsuranceCol = new MongoDBCollection("Insurance");
InsuranceCol.AddAttributes("_id", "name", "value");
MongoSchema Schema = new MongoSchema("Schema", new List <MongoDBCollection> {
PersonCol, CarCol, GarageCol, RepairedCol, SupplierCol, InsuranceCol
});
// Map Rules
MapRule PersonRule = new MapRule(Person, PersonCol);
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
PersonRule.AddRule("insuranceId", "insuranceId");
MapRule CarRule = new MapRule(Car, CarCol);
CarRule.AddRule("carId", "_id");
CarRule.AddRule("model", "model");
CarRule.AddRule("year", "year");
CarRule.AddRule("driverId", "driverId");
MapRule GarageRule = new MapRule(Garage, GarageCol);
GarageRule.AddRule("garageId", "_id");
GarageRule.AddRule("name", "name");
MapRule SupplierRule = new MapRule(Supplier, SupplierCol);
SupplierRule.AddRule("supplierId", "_id");
SupplierRule.AddRule("name", "name");
MapRule RepairedRule = new MapRule(Repaired, RepairedCol);
RepairedRule.AddRule("repairedId", "_id");
RepairedRule.AddRule("carId", "carId");
RepairedRule.AddRule("garageId", "garageId");
RepairedRule.AddRule("supplierId", "supplierId");
RepairedRule.AddRule("repaired", "repaired");
MapRule InsuranceRule = new MapRule(Insurance, InsuranceCol);
InsuranceRule.AddRule("insuranceId", "_id");
InsuranceRule.AddRule("name", "name");
InsuranceRule.AddRule("value", "value");
ModelMapping Map = new ModelMapping("Map", new List <MapRule> {
PersonRule, CarRule, GarageRule, RepairedRule, SupplierRule, InsuranceRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}
public static DataContainer CreateDataContainer()
{
// ER MODEL
Entity Person = new Entity("Person");
Person.AddAttribute("id", true);
Person.AddAttributes("name", "surname", "salary");
Entity Car = new Entity("Car");
Car.AddAttribute("id", true);
Car.AddAttributes("reg_no");
Entity InsuranceCompany = new Entity("InsuranceCompany");
InsuranceCompany.AddAttribute("id", true);
InsuranceCompany.AddAttributes("name");
Entity Garage = new Entity("Garage");
Garage.AddAttribute("id", true);
Garage.AddAttributes("name", "phone");
Relationship Insurance = new Relationship("Insurance");
Insurance.AddAttributes("contract");
Insurance.AddRelationshipEnd(new RelationshipEnd(Person));
Insurance.AddRelationshipEnd(new RelationshipEnd(Car));
Insurance.AddRelationshipEnd(new RelationshipEnd(InsuranceCompany));
Relationship Drives = new Relationship("Drives");
Drives.AddRelationshipEnd(new RelationshipEnd(Person));
Drives.AddRelationshipEnd(new RelationshipEnd(Car));
Relationship Repaired = new Relationship("Repaired");
Repaired.AddAttributes("date");
Repaired.AddRelationshipEnd(new RelationshipEnd(Car));
Repaired.AddRelationshipEnd(new RelationshipEnd(Garage));
ERModel Model = new ERModel("SampleModel", new List <BaseERElement>()
{
Person, Car, InsuranceCompany, Garage, Insurance, Drives, Repaired
});
// SCHEMA
MongoDBCollection PersonCol = new MongoDBCollection("PersonCollection");
PersonCol.AddAttributes("_id", "fName", "fSurname", "fSalary");
MongoDBCollection CarCol = new MongoDBCollection("CarCollection");
CarCol.AddAttributes("_id", "fReg_no");
MongoDBCollection InsuranceCompanyCol = new MongoDBCollection("InsuranceCompanyCollection");
InsuranceCompanyCol.AddAttributes("_id", "fName");
MongoDBCollection GarageCol = new MongoDBCollection("GarageCollection");
GarageCol.AddAttributes("_id", "fName", "fPhone");
MongoDBCollection InsuranceCol = new MongoDBCollection("InsuranceCollection");
InsuranceCol.AddAttributes("contract");
MongoDBCollection DrivesCol = new MongoDBCollection("DrivesCollection");
DrivesCol.AddAttributes("fPersonId", "fCarId");
MongoDBCollection RepairedCol = new MongoDBCollection("RepairedCollection");
RepairedCol.AddAttributes("fCarId", "fGarageId", "fDate");
MongoSchema Schema = new MongoSchema("SampleSchema", new List <MongoDBCollection>()
{
PersonCol, CarCol, InsuranceCompanyCol, GarageCol, InsuranceCol, DrivesCol, RepairedCol
});
// Mapping
MapRule PersonRule = new MapRule(Person, PersonCol);
PersonRule.AddRule("id", "_id");
PersonRule.AddRule("name", "fName");
PersonRule.AddRule("surname", "fSurname");
PersonRule.AddRule("salary", "fSalary");
MapRule CarRule = new MapRule(Car, CarCol);
CarRule.AddRule("id", "_id");
CarRule.AddRule("reg_no", "fReg_no");
MapRule InsCompanyRule = new MapRule(InsuranceCompany, InsuranceCompanyCol);
InsCompanyRule.AddRule("id", "_id");
InsCompanyRule.AddRule("name", "fName");
MapRule GarageRule = new MapRule(Garage, GarageCol);
GarageRule.AddRule("id", "_id");
GarageRule.AddRule("name", "fName");
GarageRule.AddRule("phone", "fPhone");
MapRule InsuranceRule = new MapRule(Insurance, InsuranceCol);
InsuranceRule.AddRule("contract", "contract");
MapRule PersonInsuranceRule = new MapRule(Person, InsuranceCol, false);
PersonInsuranceRule.AddRule("id", "fPersonId");
MapRule CarInsuranceRule = new MapRule(Car, InsuranceCol, false);
CarInsuranceRule.AddRule("id", "fCarId");
MapRule InsCompanyInsuranceRule = new MapRule(InsuranceCompany, InsuranceCol, false);
InsCompanyInsuranceRule.AddRule("id", "fInsCoId");
MapRule DrivesRule = new MapRule(Drives, DrivesCol);
MapRule PersonDrivesRule = new MapRule(Person, DrivesCol, false);
PersonDrivesRule.AddRule("id", "fPersonId");
MapRule CarDrivesRule = new MapRule(Car, DrivesCol, false);
CarDrivesRule.AddRule("id", "fCarId");
MapRule RepairedRule = new MapRule(Repaired, RepairedCol);
RepairedRule.AddRule("date", "fDate");
MapRule CarRepairedRule = new MapRule(Car, RepairedCol, false);
CarRepairedRule.AddRule("id", "fCarId");
MapRule GarageRepairedRule = new MapRule(Garage, RepairedCol, false);
GarageRepairedRule.AddRule("id", "fGarageId");
ModelMapping Mapping = new ModelMapping("SampleMapping", new List <MapRule>()
{
PersonRule, CarRule, InsCompanyRule, GarageRule, InsuranceRule, PersonInsuranceRule, CarInsuranceRule, InsCompanyInsuranceRule, DrivesRule, PersonDrivesRule, CarDrivesRule, RepairedRule, CarRepairedRule, GarageRepairedRule
});
return(new DataContainer(Model, Schema, Mapping));
}
/// <summary>
/// Generates data to test a RJOIN operation with a one to one relationship
/// connecting to a composition of two other entities
/// </summary>
/// <returns></returns>
public static RequiredDataContainer OneToOneComputedEntity()
{
Entity Person = new Entity("Person");
Person.AddAttribute("personId", true);
Person.AddAttributes("name");
Entity Car = new Entity("Car");
Car.AddAttribute("carId", true);
Car.AddAttributes("model", "year");
Entity Garage = new Entity("Garage");
Garage.AddAttribute("garageId", true);
Garage.AddAttributes("name");
Relationship Drives = new Relationship("Drives");
Drives.AddRelationshipEnd(new RelationshipEnd(Person));
Drives.AddRelationshipEnd(new RelationshipEnd(Car));
Relationship Repaired = new Relationship("Repaired");
Repaired.AddRelationshipEnd(new RelationshipEnd(Car));
Repaired.AddRelationshipEnd(new RelationshipEnd(Garage));
Repaired.AddAttribute("repairedId", true);
Repaired.AddAttributes("repaired");
ERModel Model = new ERModel("ERModel", new List <BaseERElement> {
Person, Car, Garage, Drives, Repaired
});
// Mongo Schema
MongoDBCollection PersonCol = new MongoDBCollection("Person");
PersonCol.AddAttributes("_id", "name", "carId");
MongoDBCollection CarCol = new MongoDBCollection("Car");
CarCol.AddAttributes("_id", "model", "year");
MongoDBCollection GarageCol = new MongoDBCollection("Garage");
GarageCol.AddAttributes("_id", "name");
MongoDBCollection RepairedCol = new MongoDBCollection("Repaired");
RepairedCol.AddAttributes("_id", "carId", "garageId", "repaired");
MongoSchema Schema = new MongoSchema("Schema", new List <MongoDBCollection> {
PersonCol, CarCol, GarageCol, RepairedCol
});
// Map Rules
MapRule PersonRule = new MapRule(Person, PersonCol);
PersonRule.AddRule("personId", "_id");
PersonRule.AddRule("name", "name");
MapRule CarRule = new MapRule(Car, CarCol);
CarRule.AddRule("carId", "_id");
CarRule.AddRule("model", "model");
CarRule.AddRule("year", "year");
MapRule GarageRule = new MapRule(Garage, GarageCol);
GarageRule.AddRule("garageId", "_id");
GarageRule.AddRule("name", "name");
MapRule RepairedRule = new MapRule(Repaired, RepairedCol);
RepairedRule.AddRule("repairedId", "_id");
RepairedRule.AddRule("repaired", "repaired");
MapRule CarPersonRule = new MapRule(Car, PersonCol, false);
CarPersonRule.AddRule("carId", "carId");
MapRule CarRepairedRule = new MapRule(Car, RepairedCol, false);
CarRepairedRule.AddRule("carId", "carId");
MapRule GarageRepairedRule = new MapRule(Garage, RepairedCol, false);
GarageRepairedRule.AddRule("garageId", "garageId");
ModelMapping Map = new ModelMapping("Map", new List <MapRule> {
PersonRule, CarRule, GarageRule, RepairedRule, CarPersonRule, CarRepairedRule, GarageRepairedRule
});
return(new RequiredDataContainer(Model, Schema, Map));
}