public void RelationshipJoin()
{
RequiredDataContainer ModelData = VirtualMapDataProvider.VirtualMapModel();
QueryableEntity Person = new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Person"));
QueryableEntity Pet = new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Pet"));
RelationshipJoinOperator RJoinOp = new RelationshipJoinOperator(Person,
(Relationship)ModelData.EntityRelationshipModel.FindByName("HasPet"),
new List <QueryableEntity>()
{
Pet
},
ModelData.ERMongoMapping);
VirtualMap RJoinVMap = RJoinOp.ComputeVirtualMap();
List <string> VirtualMapRules = RJoinVMap.GetRulesAsStringList();
Assert.IsNotNull(RJoinVMap, "Virtual map cannot be null");
List <string> RulesToMatch = new List <string>()
{
"_id",
"name",
"age",
"data_HasPet.Pet_petId",
"data_HasPet.Pet_name",
"data_HasPet.Pet_type",
"data_HasPet.Pet_ownerId"
};
Assert.IsTrue(!VirtualMapRules.Except(RulesToMatch).Any() && !RulesToMatch.Except(VirtualMapRules).Any());
}
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;
RelationshipJoinOperator RJoinDrives = new RelationshipJoinOperator(
Person,
Drives,
new List <QueryableEntity>()
{
Car
},
Map);
FromArgument From = new FromArgument(Person, Map);
QueryGenerator QueryGen = new QueryGenerator(From, new List <AlgebraOperator>()
{
RJoinDrives
});
string query = QueryGen.Run();
Console.WriteLine(query);
}
public void ManyToManyComputedEntityMultipleEntities()
{
// Asserts if the query result for a relationship join operation is equal
// to a handcrafted query
RequiredDataContainer ModelData = ComputedEntityDataProvider.ManyToManyComputedEntity();
// Load handcrafted query
string HandcraftedQuery = Utils.ReadQueryFromFile("HandcraftedQueries/ceManyToMany.js");
// Assert if the handcrafted query is not null
Assert.IsNotNull(HandcraftedQuery);
// Prepare query generator
ComputedEntity CarRepairedByGarage = new ComputedEntity("CarRepairedByGarage",
new QueryableEntity(( Entity)ModelData.EntityRelationshipModel.FindByName("Car"), "car"),
(Relationship)ModelData.EntityRelationshipModel.FindByName("Repaired"),
new List <QueryableEntity> {
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("Garage"), "garage"),
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("Supplier"), "supplier")
});
RelationshipJoinOperator RJoinOp = new RelationshipJoinOperator(
new QueryableEntity(( Entity)ModelData.EntityRelationshipModel.FindByName("Person"), "person"),
(Relationship)ModelData.EntityRelationshipModel.FindByName("Owns"),
new List <QueryableEntity> {
new QueryableEntity(CarRepairedByGarage),
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("Insurance"), "insurance")
},
ModelData.ERMongoMapping);
List <AlgebraOperator> OpList = new List <AlgebraOperator> {
RJoinOp
};
FromArgument StartArg = new FromArgument(new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Person")),
ModelData.ERMongoMapping);
QueryGenerator QueryGen = new QueryGenerator(StartArg, OpList);
string GeneratedQuery = QueryGen.Run();
// Assert if generated query is not null
Assert.IsNotNull(GeneratedQuery);
// Run Queries
QueryRunner Runner = new QueryRunner("mongodb://localhost:27017", "ceManyToMany");
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)));
}
public void ManyToManyMultipleEntities()
{
// Asserts if the query result for a simple binary join is equal
// to a handcrafted query
RequiredDataContainer ModelData = ManyToManyRelationshipsDataProvider.ManyToManyMultipleEntities();
// Load handcrafted query
string HandcraftedQuery = Utils.ReadQueryFromFile("HandcraftedQueries/personCarInsCompanyManyToMany.js");
// Assert if the handcrafted query is not null
Assert.IsNotNull(HandcraftedQuery);
// Prepare query generator
// FROM Person RJOIN (Car, InsCompany)
RelationshipJoinOperator RJoinOp = new RelationshipJoinOperator(
new QueryableEntity(( Entity)ModelData.EntityRelationshipModel.FindByName("Person"), "person"),
(Relationship)ModelData.EntityRelationshipModel.FindByName("Insurance"),
new List <QueryableEntity> {
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("Car"), "car"),
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("InsCompany"), "inscompany")
},
ModelData.ERMongoMapping);
List <AlgebraOperator> OpList = new List <AlgebraOperator> {
RJoinOp
};
FromArgument StartArg = new FromArgument(new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Person")),
ModelData.ERMongoMapping);
QueryGenerator QueryGen = new QueryGenerator(StartArg, OpList);
string GeneratedQuery = QueryGen.Run();
// Assert if generated query is not null
Assert.IsNotNull(GeneratedQuery);
// Run Queries
QueryRunner Runner = new QueryRunner("mongodb://localhost:27017", "researchManyToMany");
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)));
}
public void OneToOneEmbeddedMixed()
{
//TODO: Check why it isn't working and why it didn't have a TestMethod attribute before
// Asserts if the query result for a simple binary join is equal
// to a handcrafted query
//RequiredDataContainer ModelData = OneToOneRelationshipsDataProvider.OneToOneEmbeddedMixed();
var ModelData = QueryBuilderParser.ParseMapping(Utils.ReadMappingFile("Mappings/one-to-one-embedded-mixed.mapping"));
// Load handcrafted query
string HandcraftedQuery = Utils.ReadQueryFromFile("HandcraftedQueries/personCarOneToOne_4.js");
// Assert if the handcrafted query is not null
Assert.IsNotNull(HandcraftedQuery);
// Prepare query generator
RelationshipJoinOperator RJoinOp = new RelationshipJoinOperator(
new QueryableEntity(( Entity)ModelData.EntityRelationshipModel.FindByName("Person"), "person"),
(Relationship)ModelData.EntityRelationshipModel.FindByName("Drives"),
new List <QueryableEntity> {
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("Car"), "car")
},
ModelData.ERMongoMapping);
List <AlgebraOperator> OpList = new List <AlgebraOperator> {
RJoinOp
};
FromArgument StartArg = new FromArgument(new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Person")),
ModelData.ERMongoMapping);
QueryGenerator QueryGen = new QueryGenerator(StartArg, OpList);
string GeneratedQuery = QueryGen.Run();
// Assert if generated query is not null
Assert.IsNotNull(GeneratedQuery);
// Run Queries
QueryRunner Runner = new QueryRunner("mongodb://localhost:27017", "researchDatabase");
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)));
}
public static string _getQueryForTestAllProducts(DataContainer DataMap, QueryableEntity Product, QueryableEntity Store, QueryableEntity Category, QueryableEntity User)
{
RelationshipJoinOperator RJoinProductUser = new RelationshipJoinOperator(
Product,
(Relationship)DataMap.EntityRelationshipModel.FindByName("UserProducts"),
new List <QueryableEntity>()
{
User
},
DataMap.ERMongoMapping);
RelationshipJoinOperator RJoinProductStore = new RelationshipJoinOperator(
Product,
(Relationship)DataMap.EntityRelationshipModel.FindByName("StoreProducts"),
new List <QueryableEntity>()
{
Store
},
DataMap.ERMongoMapping);
RelationshipJoinOperator RJoinProductCategory = new RelationshipJoinOperator(
Product,
(Relationship)DataMap.EntityRelationshipModel.FindByName("CategoryProducts"),
new List <QueryableEntity>()
{
Category
},
DataMap.ERMongoMapping);
SortArgument SortArg = new SortArgument(Product, Product.GetAttribute("product_id"), MongoDBSort.Ascending);
SortStage SortOp = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMap.ERMongoMapping);
List <AlgebraOperator> Operators = new List <AlgebraOperator>()
{
RJoinProductUser, RJoinProductStore, RJoinProductCategory, SortOp
};
FromArgument FromArg = new FromArgument(Product, DataMap.ERMongoMapping);
QueryGenerator QueryGen = new QueryGenerator(FromArg, Operators);
string Query = QueryGen.Run();
return(Query);
}
public void ProjectStageShowFields()
{
//RequiredDataContainer ModelData = VirtualMapDataProvider.VirtualMapModel();
var ModelData = QueryBuilderParser.ParseMapping(Utils.ReadMappingFile("Mappings/virtual-map.mapping"));
QueryableEntity Person = new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Person"));
QueryableEntity Pet = new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Pet"));
RelationshipJoinOperator RJoinOp = new RelationshipJoinOperator(
Person,
(Relationship)ModelData.EntityRelationshipModel.FindByName("HasPet"),
new List <QueryableEntity>()
{
Pet
},
ModelData.ERMongoMapping);
VirtualMap RJoinVMap = RJoinOp.ComputeVirtualMap();
Assert.IsNotNull(RJoinVMap, "RJOIN Virtual map cannot be null");
List <ProjectArgument> ProjectArguments = new List <ProjectArgument>();
ProjectArguments.Add(new ProjectArgument(Person.GetAttribute("name"), Person, new BooleanExpr(true)));
ProjectArguments.Add(new ProjectArgument(Person.GetAttribute("age"), Person, new BooleanExpr(true)));
ProjectArguments.Add(new ProjectArgument(Pet.GetAttribute("name"), Pet, new BooleanExpr(true)));
ProjectStage ProjectOp = new ProjectStage(ProjectArguments, RJoinVMap);
VirtualMap ProjectVirtualMap = ProjectOp.ComputeVirtualMap(RJoinVMap);
Assert.IsNotNull(ProjectVirtualMap, "Project virtual map cannot be null");
List <string> VirtualMapRules = ProjectVirtualMap.GetRulesAsStringList();
List <string> RulesToMatch = new List <string>()
{
"name",
"age",
"data_HasPet.Pet_name",
};
Assert.IsTrue(!VirtualMapRules.Except(RulesToMatch).Any() && !RulesToMatch.Except(VirtualMapRules).Any(), "Virtual maps do not match");
}
private void GenerateQuery(RequiredDataContainer Container, string Database)
{
QueryableEntity Aluno = new QueryableEntity(Container.EntityRelationshipModel.FindByName("Aluno"));
QueryableEntity Endereco = new QueryableEntity(Container.EntityRelationshipModel.FindByName("Endereco"));
RelationshipJoinOperator RJoinOp = new RelationshipJoinOperator(
Aluno,
(Relationship)Container.EntityRelationshipModel.FindByName("AlunoMora"),
new List <QueryableEntity>()
{
Endereco
},
Container.ERMongoMapping);
SortArgument SortArg = new SortArgument(Aluno, Aluno.Element.GetIdentifierAttribute(), MongoDBSort.Ascending);
SortStage SortOp = new SortStage(new List <SortArgument>()
{
SortArg
}, Container.ERMongoMapping);
List <AlgebraOperator> OperatorList = new List <AlgebraOperator>()
{
RJoinOp, SortOp
};
FromArgument FromArg = new FromArgument(Aluno, Container.ERMongoMapping);
QueryGenerator QueryGen = new QueryGenerator(FromArg, OperatorList);
string Query = QueryGen.Run();
Beautifier jsB = new Beautifier();
queryBox.Text = jsB.Beautify(Query);
QueryRunner QueryRunner = new QueryRunner("mongodb://localhost:27017", Database);
string Result = QueryRunner.GetJSON(Query);
resultBox.Text = Result.PrettyPrintJson();
}
static void Main(string[] args)
{
var mapping = QueryBuilderParser.ParseMapping(new FileStream(args[0], FileMode.Open));
Console.WriteLine($"ERModel: {mapping.EntityRelationshipModel.Name}");
Console.WriteLine("\n\n****** ER Model ********\n\n");
foreach (var e in mapping.EntityRelationshipModel.Elements.FindAll(e => e.GetType() == typeof(Entity)))
{
Console.WriteLine($"Entity: {e.Name}");
e.Attributes.ForEach(a =>
{
Console.WriteLine($" Attribute: {a.Name} of type {a.OfType}, multivalued={a.MultiValued}");
});
}
foreach (var r in mapping.EntityRelationshipModel.Elements.FindAll(e => e.GetType() == typeof(Relationship)).ConvertAll <Relationship>(e => (Relationship)e))
{
Console.WriteLine($"Relationship: {r.Name}");
r.Ends.ForEach(e =>
{
Console.WriteLine($" End: {e.TargetEntity.Name}");
});
r.Attributes.ForEach(a =>
{
Console.WriteLine($" Attribute: {a.Name} of type {a.OfType}, multivalued={a.MultiValued}");
});
}
Console.WriteLine("\n\n****** Mongo DB Schema ********\n\n");
foreach (var c in mapping.MongoDBSchema.Collections)
{
Console.WriteLine($"Collection: {c.Name}");
c.DocumentSchema.Attributes.ForEach(a =>
{
Console.WriteLine($" Field: {a.Name} of type {a.OfType}, multivalued={a.MultiValued}");
});
}
Console.WriteLine("\n\n****** Mapping ********\n\n");
foreach (var r in mapping.ERMongoMapping.Rules)
{
Console.WriteLine($"Rule: {r.Source.Name} = {r.Target.Name} (Main={r.IsMain})");
foreach (var sr in r.Rules)
{
Console.WriteLine($" {sr.Key} - {sr.Value}");
}
}
Console.WriteLine("\n\n****** Warnings and Errors ********\n\n");
mapping.Warnings.ForEach(w => Console.WriteLine(w));
mapping.Errors.ForEach(e => Console.WriteLine(e));
//string[] queries = { "from Author a rjoin <BookAndAuthor ba> (Book b)" };
string[] queries = { "from Author a rjoin <BookAndAuthor ba> (Book b rjoin <PublishedBy pb> (Publisher p))" };
// string[] queries = { "from Person p rjoin <Insurance i> (Car c, InsuranceCompany ic)",
// "from Car c rjoin <Repaired r> (Garage g)",
// "from Person p rjoin <Insurance i> (Car c rjoin <Repaired r> (Garage g), InsuranceCompany ic)",
// "from (Person p rjoin <Drives d> (Car c)) rjoin <Repaired r> (Garage g)",
// "from (Person p rjoin <Drives d> (Car c rjoin <Repaired r> (Garage g)))",
// "from Person p rjoin <Drives d> (Car c rjoin <Repaired r> (Garage g))" };
foreach (var q in queries)
{
Console.WriteLine(q);
var generatedQuery = QueryBuilderParser.ParseQuery(q, mapping);
Console.WriteLine("*************");
Console.WriteLine($"Start Argument: {generatedQuery.StartArgument.Entity.Element.Name} AS {generatedQuery.StartArgument.Entity.Alias}");
var i = 1;
foreach (var Op in generatedQuery.PipelineOperators)
{
Console.WriteLine($"Operator {i++}: {Op.ToString()}");
}
Console.WriteLine("*************");
QueryRunner runner = new QueryRunner("mongodb://localhost:27017", "sampleAuthorBookPublisher");
Console.WriteLine(runner.GetJSON(generatedQuery.Run()));
}
// Nested join example using manual code
Console.WriteLine("Running example ============");
QueryableEntity Author = new QueryableEntity(mapping.EntityRelationshipModel.FindByName("Author"));
QueryableEntity Book = new QueryableEntity(mapping.EntityRelationshipModel.FindByName("Book"));
QueryableEntity Publisher = new QueryableEntity(mapping.EntityRelationshipModel.FindByName("Publisher"));
Relationship BookAndAuthor = (Relationship)mapping.EntityRelationshipModel.FindByName("BookAndAuthor");
Relationship PublishedBy = (Relationship)mapping.EntityRelationshipModel.FindByName("PublishedBy");
ComputedEntity BookAndPublisher = new ComputedEntity("BookAndPublisher", Book,
PublishedBy, new List <QueryableEntity>()
{
Publisher
});
RelationshipJoinOperator JoinOp = new RelationshipJoinOperator(Author, BookAndAuthor,
new List <QueryableEntity>()
{
new QueryableEntity(BookAndPublisher)
},
mapping.ERMongoMapping);
FromArgument fromArg = new FromArgument(Author, mapping.ERMongoMapping);
List <AlgebraOperator> Operations = new List <AlgebraOperator>()
{
JoinOp
};
QueryGenerator queryGen = new QueryGenerator(fromArg, Operations);
string queryString = queryGen.Run();
QueryRunner queryRunner = new QueryRunner("mongodb://localhost:27017", "sampleAuthorBookPublisher");
Console.WriteLine(queryRunner.GetJSON(queryString));
}
public void ProjectComputedEntity()
{
// Asserts if the query result for a relationship join operation is equal
// to a handcrafted query
RequiredDataContainer ModelData = ProjectDataProvider.ComputedEntityData();
// Load handcrafted query
string HandcraftedQuery = Utils.ReadQueryFromFile("HandcraftedQueries/projectQuery.js");
// Assert if the handcrafted query is not null
Assert.IsNotNull(HandcraftedQuery);
// Prepare query generator
ComputedEntity CarRepairedByGarage = new ComputedEntity("CarManufacturedBy",
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("Car"), "car"),
(Relationship)ModelData.EntityRelationshipModel.FindByName("ManufacturedBy"),
new List <QueryableEntity> {
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("Manufacturer"), "manufacturer")
});
RelationshipJoinOperator RJoinOp = new RelationshipJoinOperator(
new QueryableEntity((Entity)ModelData.EntityRelationshipModel.FindByName("Person"), "person"),
(Relationship)ModelData.EntityRelationshipModel.FindByName("Owns"),
new List <QueryableEntity> {
new QueryableEntity(CarRepairedByGarage)
},
ModelData.ERMongoMapping);
VirtualMap VMap = RJoinOp.ComputeVirtualMap();
Dictionary <string, ProjectExpression> ProjectPersonAttrs = new Dictionary <string, ProjectExpression>();
QueryableEntity Person = new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Person"));
QueryableEntity Car = new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Car"));
QueryableEntity Manufacturer = new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Manufacturer"));
List <ProjectArgument> ProjectArguments = new List <ProjectArgument>();
ProjectArguments.Add(new ProjectArgument(Person.GetAttribute("name"), Person, new BooleanExpr(true)));
ProjectArguments.Add(new ProjectArgument(Car.GetAttribute("model"), Car, new BooleanExpr(true)));
ProjectArguments.Add(new ProjectArgument(Car.GetAttribute("year"), Car, new BooleanExpr(true)));
ProjectArguments.Add(new ProjectArgument(Manufacturer.GetAttribute("name"), Manufacturer, new BooleanExpr(true)));
ProjectStage ProjectOp = new ProjectStage(ProjectArguments, VMap);
List <AlgebraOperator> OpList = new List <AlgebraOperator> {
RJoinOp, ProjectOp
};
FromArgument StartArg = new FromArgument(new QueryableEntity(ModelData.EntityRelationshipModel.FindByName("Person")),
ModelData.ERMongoMapping);
QueryGenerator QueryGen = new QueryGenerator(StartArg, OpList);
string GeneratedQuery = QueryGen.Run();
// Assert if generated query is not null
Assert.IsNotNull(GeneratedQuery);
// Run Queries
QueryRunner Runner = new QueryRunner("mongodb://localhost:27017", "ceManyToMany2");
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)));
}
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();
}
public void GetAllProductsFromStore()
{
RequiredDataContainer DataMap = MarketingCMSDataProvider.MapEntitiesToCollections();
RequiredDataContainer DataMapDuplicates = MarketingCMSDataProvider.MapEntitiesToCollectionDuplicates();
RequiredDataContainer DataMapCategoryDuplicated = MarketingCMSDataProvider.MapEntitiesToCollectionCategoryDuplicated();
RequiredDataContainer DataMapStoreDuplicated = MarketingCMSDataProvider.MapEntitiesToCollectionsStoreDuplicated();
RequiredDataContainer DataMapUserDuplicated = MarketingCMSDataProvider.MapEntitiesToCollectionsUserDuplicated();
QueryableEntity Store = new QueryableEntity(DataMap.EntityRelationshipModel.FindByName("Store"));
QueryableEntity Product = new QueryableEntity(DataMap.EntityRelationshipModel.FindByName("Product"));
RelationshipJoinOperator JoinOpMap1 = new RelationshipJoinOperator(Store,
(Relationship)DataMap.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Product
},
DataMap.ERMongoMapping);
RelationshipJoinOperator JoinOpMap2 = new RelationshipJoinOperator(Store,
(Relationship)DataMapDuplicates.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Product
},
DataMapDuplicates.ERMongoMapping);
RelationshipJoinOperator JoinOpMap3 = new RelationshipJoinOperator(Store,
(Relationship)DataMapCategoryDuplicated.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Product
},
DataMapCategoryDuplicated.ERMongoMapping);
RelationshipJoinOperator JoinOpMap4 = new RelationshipJoinOperator(Store,
(Relationship)DataMapStoreDuplicated.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Product
},
DataMapStoreDuplicated.ERMongoMapping);
RelationshipJoinOperator JoinOpMap5 = new RelationshipJoinOperator(Store,
(Relationship)DataMapUserDuplicated.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Product
},
DataMapUserDuplicated.ERMongoMapping);
SortArgument SortArg = new SortArgument(Store, Store.GetAttribute("store_id"), MongoDBSort.Ascending);
SortStage SortOpMap1 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMap.ERMongoMapping);
SortStage SortOpMap2 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMapDuplicates.ERMongoMapping);
SortStage SortOpMap3 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMapCategoryDuplicated.ERMongoMapping);
SortStage SortOpMap4 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMapStoreDuplicated.ERMongoMapping);
SortStage SortOpMap5 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMapUserDuplicated.ERMongoMapping);
List <AlgebraOperator> OperatorsToExecuteMap1 = new List <AlgebraOperator>()
{
JoinOpMap1, SortOpMap1
};
List <AlgebraOperator> OperatorsToExecuteMap2 = new List <AlgebraOperator>()
{
JoinOpMap2, SortOpMap2
};
List <AlgebraOperator> OperatorsToExecuteMap3 = new List <AlgebraOperator>()
{
JoinOpMap3, SortOpMap3
};
List <AlgebraOperator> OperatorsToExecuteMap4 = new List <AlgebraOperator>()
{
JoinOpMap4, SortOpMap4
};
List <AlgebraOperator> OperatorsToExecuteMap5 = new List <AlgebraOperator>()
{
JoinOpMap5, SortOpMap5
};
FromArgument StartArgMap1 = new FromArgument(Store, DataMap.ERMongoMapping);
FromArgument StartArgMap2 = new FromArgument(Store, DataMapDuplicates.ERMongoMapping);
FromArgument StartArgMap3 = new FromArgument(Store, DataMapCategoryDuplicated.ERMongoMapping);
FromArgument StartArgMap4 = new FromArgument(Store, DataMapStoreDuplicated.ERMongoMapping);
FromArgument StartArgMap5 = new FromArgument(Store, DataMapUserDuplicated.ERMongoMapping);
QueryGenerator GeneratorMap1 = new QueryGenerator(StartArgMap1, OperatorsToExecuteMap1);
QueryGenerator GeneratorMap2 = new QueryGenerator(StartArgMap2, OperatorsToExecuteMap2);
QueryGenerator GeneratorMap3 = new QueryGenerator(StartArgMap3, OperatorsToExecuteMap3);
QueryGenerator GeneratorMap4 = new QueryGenerator(StartArgMap4, OperatorsToExecuteMap4);
QueryGenerator GeneratorMap5 = new QueryGenerator(StartArgMap5, OperatorsToExecuteMap5);
string QueryMap1 = GeneratorMap1.Run();
string QueryMap2 = GeneratorMap2.Run();
string QueryMap3 = GeneratorMap3.Run();
string QueryMap4 = GeneratorMap4.Run();
string QueryMap5 = GeneratorMap5.Run();
Assert.IsNotNull(QueryMap1, "Query [Map1] cannot be null");
Assert.IsNotNull(QueryMap2, "Query [Map2] cannot be null");
Assert.IsNotNull(QueryMap3, "Query [Map3] cannot be null");
Assert.IsNotNull(QueryMap4, "Query [Map4] cannot be null");
Assert.IsNotNull(QueryMap5, "Query [Map5] cannot be null");
QueryRunner RunnerMap1 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms");
QueryRunner RunnerMap2 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms_duplicados");
QueryRunner RunnerMap3 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms_category_duplicado");
QueryRunner RunnerMap4 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms_store_duplicado");
QueryRunner RunnerMap5 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms_user_duplicado");
string ResultMap1 = RunnerMap1.GetJSON(QueryMap1);
string ResultMap2 = RunnerMap2.GetJSON(QueryMap2);
string ResultMap3 = RunnerMap3.GetJSON(QueryMap3);
string ResultMap4 = RunnerMap4.GetJSON(QueryMap4);
string ResultMap5 = RunnerMap5.GetJSON(QueryMap5);
Assert.IsNotNull(ResultMap1, "Result [Map1] cannot be null");
Assert.IsNotNull(ResultMap2, "Result [Map2] cannot be null");
Assert.IsNotNull(ResultMap3, "Result [Map3] cannot be null");
Assert.IsNotNull(ResultMap4, "Result [Map4] cannot be null");
Assert.IsNotNull(ResultMap5, "Result [Map5] cannot be null");
Assert.IsTrue(ResultMap1 != string.Empty, "Result [Map1] cannot be empty");
Assert.IsTrue(ResultMap2 != string.Empty, "Result [Map2] cannot be empty");
Assert.IsTrue(ResultMap3 != string.Empty, "Result [Map3] cannot be empty");
Assert.IsTrue(ResultMap4 != string.Empty, "Result [Map4] cannot be empty");
Assert.IsTrue(ResultMap5 != string.Empty, "Result [Map5] cannot be empty");
Assert.IsTrue(JToken.DeepEquals(JToken.Parse(ResultMap1), JToken.Parse(ResultMap2)));
Assert.IsTrue(JToken.DeepEquals(JToken.Parse(ResultMap1), JToken.Parse(ResultMap3)));
Assert.IsTrue(JToken.DeepEquals(JToken.Parse(ResultMap1), JToken.Parse(ResultMap4)));
Assert.IsTrue(JToken.DeepEquals(JToken.Parse(ResultMap1), JToken.Parse(ResultMap5)));
}
public void GetAllProducts()
{
RequiredDataContainer DataMap = MarketingCMSDataProvider.MapEntitiesToCollections();
RequiredDataContainer DataMapDuplicates = MarketingCMSDataProvider.MapEntitiesToCollectionDuplicates();
RequiredDataContainer DataMapCategoryDuplicated = MarketingCMSDataProvider.MapEntitiesToCollectionCategoryDuplicated();
RequiredDataContainer DataMapStoreDuplicated = MarketingCMSDataProvider.MapEntitiesToCollectionsStoreDuplicated();
RequiredDataContainer DataMapUserDuplicated = MarketingCMSDataProvider.MapEntitiesToCollectionsUserDuplicated();
QueryableEntity Product = new QueryableEntity(DataMap.EntityRelationshipModel.FindByName("Product"));
QueryableEntity Store = new QueryableEntity(DataMap.EntityRelationshipModel.FindByName("Store"));
QueryableEntity Category = new QueryableEntity(DataMap.EntityRelationshipModel.FindByName("Category"));
QueryableEntity User = new QueryableEntity(DataMap.EntityRelationshipModel.FindByName("User"));
RelationshipJoinOperator RJoinStoreMap1 = new RelationshipJoinOperator(Product,
(Relationship)DataMap.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Store
},
DataMap.ERMongoMapping);
RelationshipJoinOperator RJoinCategoryMap1 = new RelationshipJoinOperator(Product,
(Relationship)DataMap.EntityRelationshipModel.FindByName("CategoryHasManyProducts"),
new List <QueryableEntity>()
{
Category
},
DataMap.ERMongoMapping);
RelationshipJoinOperator RJoinUserMap1 = new RelationshipJoinOperator(Product,
(Relationship)DataMap.EntityRelationshipModel.FindByName("HasManyProducts"),
new List <QueryableEntity>()
{
User
},
DataMap.ERMongoMapping);
// DEBUG
//LimitStage LimitOp = new LimitStage( 150000 );
SortArgument SortArg = new SortArgument(Product, Product.GetAttribute("product_id"), MongoDBSort.Ascending);
SortStage SortOp = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMap.ERMongoMapping);
SortStage SortOp2 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMapDuplicates.ERMongoMapping);
SortStage SortOp3 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMapCategoryDuplicated.ERMongoMapping);
SortStage SortOp4 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMapStoreDuplicated.ERMongoMapping);
SortStage SortOp5 = new SortStage(new List <SortArgument>()
{
SortArg
}, DataMapUserDuplicated.ERMongoMapping);
// =====
// Build and execute Map1 query
List <AlgebraOperator> Map1OperatorsList = new List <AlgebraOperator>()
{
RJoinStoreMap1, RJoinCategoryMap1, RJoinUserMap1, SortOp
};
FromArgument StartArgMap1 = new FromArgument(Product, DataMap.ERMongoMapping);
QueryGenerator Generator = new QueryGenerator(StartArgMap1, Map1OperatorsList);
string Map1Query = Generator.Run();
Assert.IsNotNull(Map1Query, "Generated query [Map1Query] cannot be null");
RelationshipJoinOperator RJoinStoreMap2 = new RelationshipJoinOperator(Product,
(Relationship)DataMapDuplicates.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Store
},
DataMapDuplicates.ERMongoMapping);
RelationshipJoinOperator RJoinCategoryMap2 = new RelationshipJoinOperator(Product,
(Relationship)DataMapDuplicates.EntityRelationshipModel.FindByName("CategoryHasManyProducts"),
new List <QueryableEntity>()
{
Category
},
DataMapDuplicates.ERMongoMapping);
RelationshipJoinOperator RJoinUserMap2 = new RelationshipJoinOperator(Product,
(Relationship)DataMapDuplicates.EntityRelationshipModel.FindByName("HasManyProducts"),
new List <QueryableEntity>()
{
User
},
DataMapDuplicates.ERMongoMapping);
List <AlgebraOperator> MapDuplicatesOpList = new List <AlgebraOperator>()
{
RJoinStoreMap2, RJoinCategoryMap2, RJoinUserMap2, SortOp2
};
FromArgument StartArgMap2 = new FromArgument(Product, DataMapDuplicates.ERMongoMapping);
QueryGenerator GeneratorDuplicates = new QueryGenerator(StartArgMap2, MapDuplicatesOpList);
string MapDuplicatesQuery = GeneratorDuplicates.Run();
Assert.IsNotNull(MapDuplicatesQuery, "Generated query [MapDuplicatesQuery] cannot be null");
RelationshipJoinOperator RJoinStoreMap3 = new RelationshipJoinOperator(Product,
(Relationship)DataMapCategoryDuplicated.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Store
},
DataMapCategoryDuplicated.ERMongoMapping);
RelationshipJoinOperator RJoinCategoryMap3 = new RelationshipJoinOperator(Product,
(Relationship)DataMapCategoryDuplicated.EntityRelationshipModel.FindByName("CategoryHasManyProducts"),
new List <QueryableEntity>()
{
Category
},
DataMapCategoryDuplicated.ERMongoMapping);
RelationshipJoinOperator RJoinUserMap3 = new RelationshipJoinOperator(Product,
(Relationship)DataMapCategoryDuplicated.EntityRelationshipModel.FindByName("HasManyProducts"),
new List <QueryableEntity>()
{
User
},
DataMapCategoryDuplicated.ERMongoMapping);
List <AlgebraOperator> MapCategoryDuplicatedOpList = new List <AlgebraOperator>()
{
RJoinStoreMap3, RJoinCategoryMap3, RJoinUserMap3, SortOp3
};
FromArgument StartArgCategoryDuplicated = new FromArgument(Product, DataMapCategoryDuplicated.ERMongoMapping);
QueryGenerator GeneratorCategoryDuplicated = new QueryGenerator(StartArgCategoryDuplicated, MapCategoryDuplicatedOpList);
string MapCategoryDuplicatedQuery = GeneratorCategoryDuplicated.Run();
Assert.IsNotNull(MapCategoryDuplicatedQuery, "Generated query [MapCategoryDuplicatedQuery] cannot be null");
RelationshipJoinOperator RJoinStoreMap4 = new RelationshipJoinOperator(Product,
(Relationship)DataMapStoreDuplicated.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Store
},
DataMapStoreDuplicated.ERMongoMapping);
RelationshipJoinOperator RJoinCategoryMap4 = new RelationshipJoinOperator(Product,
(Relationship)DataMapStoreDuplicated.EntityRelationshipModel.FindByName("CategoryHasManyProducts"),
new List <QueryableEntity>()
{
Category
},
DataMapStoreDuplicated.ERMongoMapping);
RelationshipJoinOperator RJoinUserMap4 = new RelationshipJoinOperator(Product,
(Relationship)DataMapStoreDuplicated.EntityRelationshipModel.FindByName("HasManyProducts"),
new List <QueryableEntity>()
{
User
},
DataMapStoreDuplicated.ERMongoMapping);
List <AlgebraOperator> MapStoreDuplicatedOpList = new List <AlgebraOperator>()
{
RJoinStoreMap4, RJoinCategoryMap4, RJoinUserMap4, SortOp4
};
FromArgument StartArgStoreDuplicated = new FromArgument(Product, DataMapStoreDuplicated.ERMongoMapping);
QueryGenerator GeneratorStoreDuplicated = new QueryGenerator(StartArgStoreDuplicated, MapStoreDuplicatedOpList);
string MapStoreDuplicatedQuery = GeneratorStoreDuplicated.Run();
Assert.IsNotNull(MapStoreDuplicatedQuery, "Generated query [MapStoreDuplicatedQuery] cannot be null");
RelationshipJoinOperator RJoinStoreMap5 = new RelationshipJoinOperator(Product,
(Relationship)DataMapUserDuplicated.EntityRelationshipModel.FindByName("StoreHasManyProducts"),
new List <QueryableEntity>()
{
Store
},
DataMapUserDuplicated.ERMongoMapping);
RelationshipJoinOperator RJoinCategoryMap5 = new RelationshipJoinOperator(Product,
(Relationship)DataMapUserDuplicated.EntityRelationshipModel.FindByName("CategoryHasManyProducts"),
new List <QueryableEntity>()
{
Category
},
DataMapUserDuplicated.ERMongoMapping);
RelationshipJoinOperator RJoinUserMap5 = new RelationshipJoinOperator(Product,
(Relationship)DataMapUserDuplicated.EntityRelationshipModel.FindByName("HasManyProducts"),
new List <QueryableEntity>()
{
User
},
DataMapUserDuplicated.ERMongoMapping);
List <AlgebraOperator> MapUserDuplicatedOpList = new List <AlgebraOperator>()
{
RJoinStoreMap5, RJoinCategoryMap5, RJoinUserMap5, SortOp5
};
FromArgument StartArgUserDuplicated = new FromArgument(Product, DataMapUserDuplicated.ERMongoMapping);
QueryGenerator GeneratorUserDuplicated = new QueryGenerator(StartArgUserDuplicated, MapUserDuplicatedOpList);
string MapUserDuplicatedQuery = GeneratorUserDuplicated.Run();
Assert.IsNotNull(MapUserDuplicatedQuery, "Generated query [MapUserDuplicatedQuery] cannot be null");
QueryRunner RunnerMap1 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms");
QueryRunner RunnerMap2 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms_duplicados");
QueryRunner RunnerMap3 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms_category_duplicado");
QueryRunner RunnerMap4 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms_store_duplicado");
QueryRunner RunnerMap5 = new QueryRunner("mongodb://localhost:27017", "pesquisa_cms_user_duplicado");
string ResultMap1 = RunnerMap1.GetJSON(Map1Query);
string ResultMap2 = RunnerMap2.GetJSON(MapDuplicatesQuery);
string ResultMap3 = RunnerMap3.GetJSON(MapCategoryDuplicatedQuery);
string ResultMap4 = RunnerMap4.GetJSON(MapStoreDuplicatedQuery);
string ResultMap5 = RunnerMap5.GetJSON(MapUserDuplicatedQuery);
Assert.IsNotNull(ResultMap1, "Result [Map1] cannot be null");
Assert.IsNotNull(ResultMap2, "Result [Map2] cannot be null");
Assert.IsNotNull(ResultMap3, "Result [Map3] cannot be null");
Assert.IsNotNull(ResultMap4, "Result [Map4] cannot be null");
Assert.IsNotNull(ResultMap5, "Result [Map5] cannot be null");
Assert.IsTrue(JToken.DeepEquals(JToken.Parse(ResultMap1), JToken.Parse(ResultMap2)));
Assert.IsTrue(JToken.DeepEquals(JToken.Parse(ResultMap1), JToken.Parse(ResultMap3)));
Assert.IsTrue(JToken.DeepEquals(JToken.Parse(ResultMap1), JToken.Parse(ResultMap4)));
Assert.IsTrue(JToken.DeepEquals(JToken.Parse(ResultMap1), JToken.Parse(ResultMap5)));
}
