/// <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> /// Process stage and generates the corresponding commands /// </summary> /// <returns></returns> public override AlgebraOperatorResult Run(IModelMap inMap, IEnumerable <ProjectArgument> inAttributesToProject = null) { RuleMap = inMap; // Store operators to execute List <MongoDBOperator> OperatorsToExecute = new List <MongoDBOperator>(); // Store attributes and their sort option Dictionary <string, MongoDBSort> SortByTheseFields = new Dictionary <string, MongoDBSort>(); // Iterate arguments foreach (SortArgument Argument in Arguments) { // Retrieve attribute map // Check if the MapRules is an instance of ModelMapping // If so, fetch the main mapping string AttributeMap = string.Empty; if (MapRules is ModelMapping) { MapRule Rule = (MapRules as ModelMapping).Rules.FirstOrDefault(R => R.Source.Name == Argument.Entity.GetName() && R.IsMain); if (Rule == null) { throw new ImpossibleOperationException($"A main mapping is required for entity {Argument.Entity.GetName()}"); } else { AttributeMap = Rule.Rules.FirstOrDefault(R => R.Key == Argument.Attribute.Name).Value; } } else { AttributeMap = MapRules.GetRuleValue(Argument.Entity.GetAliasOrName(), Argument.Attribute.Name); } if (string.IsNullOrWhiteSpace(AttributeMap)) { continue; } SortByTheseFields.Add($"\"{AttributeMap}\"", Argument.SortOption); } // Create sort operator SortOperator SortOp = new SortOperator(SortByTheseFields); // Add to list OperatorsToExecute.Add(SortOp); // Return new Result instance return(new AlgebraOperatorResult(OperatorsToExecute)); }
/// <summary> /// Retrieve the collection based on the map rules /// </summary> /// <returns></returns> public string GetCollectionName() { /* When an entity is set in the FROM part of the query * it must have a Main mapping rule */ MapRule EntityRule = MapRules.Rules.FirstOrDefault(R => R.Source.Name == Entity.GetName() && R.IsMain); if (EntityRule == null) { throw new ImpossibleOperationException($"Entity {Entity.GetName()} doesn't have a MAIN mapping"); } return(EntityRule.Target.Name); }
/// <summary> /// Computes the virtual map after the execution of this operator /// Increments any existing virtual maps (if given) /// </summary> /// <param name="ExistingVirtualMap"></param> /// <returns></returns> public override VirtualMap ComputeVirtualMap(VirtualMap ExistingVirtualMap = null) { // Adds the prefix 'data_Entity' to attributes VirtualRule TargetVRule = new VirtualRule(TargetEntity.Element, TargetEntity.Alias); // Fetch original map for target entity MapRule TargetRule = ModelMap.Rules.First(Rule => Rule.Source.Name == TargetEntity.Element.Name && Rule.IsMain); foreach (DataAttribute Attribute in TargetEntity.Element.Attributes) { string AttributeRule = TargetRule.Rules.First(Rule => Rule.Key == Attribute.Name).Value; TargetVRule.AddRule(Attribute.Name, $"data_{TargetEntity.Element.Name}.{AttributeRule}"); } // Also process source entity rule VirtualRule SourceVRule = new VirtualRule(SourceEntity.Element, SourceEntity.Alias); // Fetch original map for source entity MapRule SourceRule = ModelMap.Rules.First(Rule => Rule.Source.Name == SourceEntity.Element.Name && Rule.IsMain); foreach (DataAttribute Attribute in SourceEntity.Element.Attributes) { string AttributeRule = SourceRule.Rules.First(Rule => Rule.Key == Attribute.Name).Value; SourceVRule.AddRule(Attribute.Name, AttributeRule); } VirtualMap VMap = new VirtualMap(new List <VirtualRule>()); VMap.Rules.AddRange(new VirtualRule[] { SourceVRule, TargetVRule }); if (ExistingVirtualMap != null) { // Check if source rule already exist if (ExistingVirtualMap.Rules.Exists(Rule => Rule.SourceERElement.Name == SourceEntity.Element.Name && Rule.Alias == SourceEntity.Alias)) { VMap.Rules.Remove(SourceVRule); } // Check if the new rules already exists if (ExistingVirtualMap.Rules.Exists(Rule => Rule.SourceERElement.Name == TargetEntity.Element.Name && Rule.Alias == TargetEntity.Alias)) { VMap.Rules.Remove(TargetVRule); } VMap.Rules.AddRange(ExistingVirtualMap.Rules); } return(VMap); }
/// <summary> /// Get the map rule result in jquery data table format, return the DataTable Result with paging and sorting. /// </summary> /// <param name="dtParams">Jquery Data Table Parameter</param> /// <param name="queryInventory">Query MapRule Object</param> /// <returns>the DataTable Result with paging and sorting</returns> public DTResult <MapRule> GetMapRuleDataTableResult(DTParams dtParams, MapRule queryMapRule) { var queryList = GetMapRuleQueryList(queryMapRule); int count = queryList.Count(); var data = new List <MapRule>(); string sortOrder = ""; if ((dtParams == null) || (dtParams.SortOrder == null)) { // 如果不是从界面进来的,是接口来的,就没有dtParams dtParams.Start = 0; dtParams.Length = count; dtParams.Order = null; sortOrder = "ID"; } else { for (int i = 0; i < dtParams.Order.Length; i++) { var order = dtParams.Order[i].Column; var sort = dtParams.Order[i].Dir; var thenByStr = dtParams.Columns[order].Data.Replace("Layout", ""); sortOrder += thenByStr + " " + sort + ","; } sortOrder = sortOrder.Substring(0, sortOrder.Length - 1); } data = queryList.OrderBy(sortOrder).Skip(dtParams.Start).Take(dtParams.Length).ToList(); DTResult <MapRule> result = new DTResult <MapRule> { flag = SUCCESS, // return call flag message = "Call Success", // return call message draw = dtParams.Draw, // how many time it have been call for this method data = data, // the data of datatable recordsFiltered = count, // records filter count recordsTotal = count // total records count }; return(result); }
public void NotInArray() { RequiredDataContainer ModelData = SelectDataProvider.GetData(); string HandcraftedQuery = Utils.ReadQueryFromFile("HandcraftedQueries/selectNotInArray.js"); Assert.IsNotNull(HandcraftedQuery); MapRule PersonRule = ModelData.ERMongoMapping.Rules.First(R => R.Source.Name == "Person"); string AgeMap = PersonRule.Rules.First(R => R.Key == "age").Value; LogicalExpression left = new LogicalExpression($"${AgeMap}", LogicalOperator.NOT_IN, new JSArray(new List <object>() { 26, 27, 28, 29 })); SelectArgument Arg = new SelectArgument(left); SelectStage SelectOp = new SelectStage(Arg, ModelData.ERMongoMapping); List <AlgebraOperator> OperatorsToExecute = new List <AlgebraOperator>() { SelectOp }; FromArgument StartArg = new FromArgument(new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Person")), ModelData.ERMongoMapping); QueryGenerator QueryGen = new QueryGenerator(StartArg, OperatorsToExecute); string GeneratedQuery = QueryGen.Run(); Assert.IsNotNull(GeneratedQuery); QueryRunner Runner = new QueryRunner("mongodb://localhost:27017", "select"); string HandcraftedResult = Runner.GetJSON(HandcraftedQuery); string GeneratedResult = Runner.GetJSON(GeneratedQuery); // Check if either result is null Assert.IsNotNull(HandcraftedResult); Assert.IsNotNull(GeneratedResult); // Check if both results are equal Assert.IsTrue(JToken.DeepEquals(JToken.Parse(HandcraftedResult), JToken.Parse(GeneratedResult))); }
/// <summary> /// Get Mapping Rule LINQ Query List /// Notice: it will retun a LINQ Query only, not the real data, you should call "toList()" to get the real data. /// </summary> /// <param name="queryMapRule">Map Rule Object</param> /// <returns>LINQ Query List,you should call "toList()" to get the real data.</returns> public IQueryable <MapRule> GetMapRuleQueryList(MapRule queryMapRule) { var mapRuleQueryList = from s in db.MapRulesDB select s; if (queryMapRule != null) { if (queryMapRule.ClientID > 0) { mapRuleQueryList = mapRuleQueryList.Where(i => i.ClientID == queryMapRule.ClientID); } if (queryMapRule.DataType > 0) { mapRuleQueryList = mapRuleQueryList.Where(i => i.DataType == queryMapRule.DataType); } if (queryMapRule.AssType > 0) { mapRuleQueryList = mapRuleQueryList.Where(i => i.AssType == queryMapRule.AssType); } } return(mapRuleQueryList); }
override public bool VisitCollection(QueryBuilderMappingParser.CollectionContext context) { if (Pass == 3) { MongoDBCollection collection = new MongoDBCollection(context.name.Text); List <MapRule> mapRules = new List <MapRule>(); if (context.erRefs() != null) { foreach (var er in context.erRefs().erRef()) { try { var erElement = EntityRelationshipModel.FindByName(er.refName.Text); var isMain = er.main == null ? false : true; MapRule mapRule = new MapRule(erElement, collection, isMain); mapRules.Add(mapRule); } catch (Exception) { Errors.Add($"Error 005: (line {er.refName.Line}:{er.refName.Column}): referenced ER element '{er.refName.Text}' not found!"); } } } foreach (var f in context.field()) { VisitField("", f, collection, mapRules); } MongoDBSchema.Collections.Add(collection); foreach (var mr in mapRules) { ERMongoMapping.Rules.Add(mr); } } return(true); }
/// <summary> /// Run operator /// </summary> /// <returns></returns> public override AlgebraOperatorResult Run(IModelMap inMap, IEnumerable <ProjectArgument> inAttributesToProject = null) { RuleMap = inMap; // This operator is quite simple // basically a lookup with an empty pipeline (no join condition) // No support for embedded entities List <MongoDBOperator> OperatorsToExecute = new List <MongoDBOperator>(); // Fetch rules MapRule TargetRule = ModelMap.Rules.First(Rule => Rule.Source.Name == TargetEntity.Element.Name && Rule.IsMain); // Create operator LookupOperator LookupOp = new LookupOperator(true) { From = TargetRule.Target.Name, Pipeline = new List <MongoDBOperator>(), As = $"data_{TargetEntity.Element.Name}" }; // Add to list OperatorsToExecute.Add(LookupOp); return(new AlgebraOperatorResult(OperatorsToExecute)); }
private void AddMapRule(MapRule mapRule) { _mappedTypes.AddRange(mapRule.GetMapRules()); }
public static void Main() { DataContainer data = CreateDataContainer(); QueryableEntity Person = new QueryableEntity(data.EntityRelationshipModel.FindByName("Person")); QueryableEntity Car = new QueryableEntity(data.EntityRelationshipModel.FindByName("Car")); Relationship Drives = (Relationship)data.EntityRelationshipModel.FindByName("Drives"); ModelMapping Map = data.ERMongoMapping; QueryableEntity Garage = new QueryableEntity(data.EntityRelationshipModel.FindByName("Garage")); RelationshipJoinOperator RJoinDrives = new RelationshipJoinOperator( Person, Drives, new List <QueryableEntity>() { Car }, Map); CartesianProductOperator CartesianOp = new CartesianProductOperator( Person, Garage, Map); ProjectArgument ProjectArg1 = new ProjectArgument(Person.GetAttribute("name"), Person, new BooleanExpr(true)); ProjectArgument ProjectArg2 = new ProjectArgument(Person.GetAttribute("surname"), Person, new BooleanExpr(true)); ProjectArgument ProjectArg3 = new ProjectArgument(Car.GetAttribute("reg_no"), Car, new BooleanExpr(true)); ProjectStage ProjectOp = new ProjectStage(new ProjectArgument[] { ProjectArg1, ProjectArg2, ProjectArg3 }, RJoinDrives.ComputeVirtualMap()); MapRule PersonRule = Map.FindMainRule(Person.Element); SelectArgument SelectArg = new SelectArgument(new EqExpr($"${PersonRule.GetRuleValueForAttribute( Person.GetAttribute( "surname" ) )}", "Smith")); SelectStage SelectOp = new SelectStage(SelectArg, Map); //List<MongoDBOperator> Operations = RJoinDrives.Run().Commands; //foreach ( MongoDBOperator Op in Operations ) //{ // Console.WriteLine( Op.GetType().Name ); // Console.WriteLine( Op.ToString() ); // Console.WriteLine( Op.ToJavaScript() ); // if ( Op is LookupOperator ) // { // LookupOperator OpAsLookup = (LookupOperator)Op; // foreach ( MongoDBOperator PipelineOp in OpAsLookup.Pipeline ) // { // Console.WriteLine( PipelineOp.GetType().Name ); // Console.WriteLine( PipelineOp.ToString() ); // Console.WriteLine( PipelineOp.ToJavaScript() ); // } // } //} QueryGenerator QueryGen = new QueryGenerator(new FromArgument(Person, Map), new List <AlgebraOperator>() { SelectOp }); string Query = QueryGen.Run(); Console.WriteLine($"Query: {Environment.NewLine}{Query}"); Console.Read(); }
private void MapDatasetRules()//this method is terrible. Doesn't matter, all of this is getting replaced, anyway. { // Console.Clear(); var inputSets = _jobState.GetinputSets(); var outputColumns = _jobState.GetOutputColumns(); var outputsetName = _jobState.GetOutputsetName(); for (int i = 0; i < inputSets.Count; i++)//loop through inputsets { var inputset = inputSets.ElementAt(i); for (int j = 0; j < inputset.Columns.Length; j++) //loop through inputset columns { for (int k = 0; k < outputColumns.Length; k++) //loop through output columns { var YNSB = ""; do { if (_ruleChecker.DoesRuleExist(inputset, k))//if a rule for the output (k) index exists, skip. { break; } _log.LogInformation("Map [{DatasetName}] column \"{inputsetColumns}\" to --> [{outputsetName}] column \"{outputColumns}\"\n", inputset.DatasetName, inputset.Columns[j], outputsetName, outputColumns[k]); _log.LogInformation("Yes, No, skip, or back [Y,N,S,B]"); YNSB = Console.ReadLine().ToUpper(); if (YNSB.Equals("Y"))//if yes, make the maprule { var rule = new MapRule { OriginIndex = j, TargetIndex = k }; inputset.MapRules.Add(rule); j++; } else if (YNSB.Equals("N"))//break do while loop, K gets incrimented { break; } else if (YNSB.Equals("S"))//Incriment J, unless J is at the last index, in whicn case, break the loop. { if (j == inputset.Columns.Length - 1) { break; } else { j++; } } else if (YNSB.Equals("B"))//this doesn't work properly yet { if (k > 0) { k--;//Need to remove a rule is the previous input generated one. Come back to this. Maybe use a queue and then convert to list once all rules are created. } else { _log.LogInformation("Can not go back any further."); } } else { _log.LogInformation("Invalid input."); } } while (true); if (YNSB.Equals("y")) { break; } } } } }
/// <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> /// Get the mapRule list result in jquery data table JSON format, return the DataTable Result with paging and sorting. /// </summary> /// <param name="dtParams">Jquery Data Table Parameter</param> /// <param name="queryInventory">Query Inventory Object</param> /// <returns>JSON: DataTable Result with paging and sorting</returns> public JsonNetResult GetMapRuleDataTableJson(DTParams dtParams, MapRule queryMapRule) { DTResult <MapRule> mapRuleDataTableResult = mapRuleService.GetMapRuleDataTableResult(dtParams, queryMapRule); return(new JsonNetResult(mapRuleDataTableResult)); }
/// <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)); }
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 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)); }
/// <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> /// 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)); }
/// <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)); }