private OutputFromComputeCellGroups ComputeCellGroups(InputForComputingCellGroups args)
{
var result = new OutputFromComputeCellGroups();
result.Success = true;
var cellCreator = new CellCreator(args.ContainerMapping);
result.Cells = cellCreator.GenerateCells();
result.Identifiers = cellCreator.Identifiers;
if (result.Cells.Count <= 0)
{
//When type-specific QVs are asked for but not defined in the MSL we should return without generating
// Query pipeline will handle this appropriately by asking for UNION ALL view.
result.Success = false;
return(result);
}
result.ForeignKeyConstraints = ForeignConstraint.GetForeignConstraints(args.ContainerMapping.StorageEntityContainer);
// Go through each table and determine their foreign key constraints
var partitioner = new CellPartitioner(result.Cells, result.ForeignKeyConstraints);
var cellGroups = partitioner.GroupRelatedCells();
//Clone cell groups- i.e, List<Set<Cell>> - upto cell before storing it in the cache because viewgen modified the Cell structure
result.CellGroups = cellGroups.Select(setOfcells => new CellGroup(setOfcells.Select(cell => new Cell(cell)))).ToList();
return(result);
}
private static ViewGenResults GenerateViewsFromCells(
List <Cell> cells,
ConfigViewGenerator config,
CqlIdentifiers identifiers,
EntityContainerMapping containerMapping)
{
EntityContainer storageEntityContainer = containerMapping.StorageEntityContainer;
ViewGenResults viewGenResults = new ViewGenResults();
ErrorLog errorLog1 = ViewgenGatekeeper.EnsureAllCSpaceContainerSetsAreMapped((IEnumerable <Cell>)cells, containerMapping);
if (errorLog1.Count > 0)
{
viewGenResults.AddErrors(errorLog1);
Helpers.StringTraceLine(viewGenResults.ErrorsToString());
return(viewGenResults);
}
List <ForeignConstraint> foreignConstraints = ForeignConstraint.GetForeignConstraints(storageEntityContainer);
foreach (Set <Cell> groupRelatedCell in new CellPartitioner((IEnumerable <Cell>)cells, (IEnumerable <ForeignConstraint>)foreignConstraints).GroupRelatedCells())
{
ViewGenerator viewGenerator = (ViewGenerator)null;
ErrorLog errorLog2 = new ErrorLog();
try
{
viewGenerator = new ViewGenerator(groupRelatedCell, config, foreignConstraints, containerMapping);
}
catch (InternalMappingException ex)
{
errorLog2 = ex.ErrorLog;
}
if (errorLog2.Count == 0)
{
errorLog2 = viewGenerator.GenerateAllBidirectionalViews(viewGenResults.Views, identifiers);
}
if (errorLog2.Count != 0)
{
viewGenResults.AddErrors(errorLog2);
}
}
return(viewGenResults);
}
private OutputFromComputeCellGroups ComputeCellGroups(
InputForComputingCellGroups args)
{
OutputFromComputeCellGroups computeCellGroups = new OutputFromComputeCellGroups();
computeCellGroups.Success = true;
CellCreator cellCreator = new CellCreator(args.ContainerMapping);
computeCellGroups.Cells = cellCreator.GenerateCells();
computeCellGroups.Identifiers = cellCreator.Identifiers;
if (computeCellGroups.Cells.Count <= 0)
{
computeCellGroups.Success = false;
return(computeCellGroups);
}
computeCellGroups.ForeignKeyConstraints = ForeignConstraint.GetForeignConstraints(args.ContainerMapping.StorageEntityContainer);
List <Set <Cell> > source = new CellPartitioner((IEnumerable <Cell>)computeCellGroups.Cells, (IEnumerable <ForeignConstraint>)computeCellGroups.ForeignKeyConstraints).GroupRelatedCells();
computeCellGroups.CellGroups = source.Select <Set <Cell>, Set <Cell> >((Func <Set <Cell>, Set <Cell> >)(setOfcells => new Set <Cell>(setOfcells.Select <Cell, Cell>((Func <Cell, Cell>)(cell => new Cell(cell)))))).ToList <Set <Cell> >();
return(computeCellGroups);
}
// effects: Given a list of cells in the schema, generates the query and
// update mapping views for OFTYPE(Extent, Type) combinations in this schema
// container. Returns a list of generated query and update views.
// If it is false and some columns in a table are unmapped, an
// exception is raised
private static ViewGenResults GenerateViewsFromCells(
List <Cell> cells, ConfigViewGenerator config,
CqlIdentifiers identifiers,
StorageEntityContainerMapping containerMapping)
{
DebugCheck.NotNull(cells);
DebugCheck.NotNull(config);
Debug.Assert(cells.Count > 0, "There must be at least one cell in the container mapping");
// Go through each table and determine their foreign key constraints
var container = containerMapping.StorageEntityContainer;
Debug.Assert(container != null);
var viewGenResults = new ViewGenResults();
var tmpLog = EnsureAllCSpaceContainerSetsAreMapped(cells, containerMapping);
if (tmpLog.Count > 0)
{
viewGenResults.AddErrors(tmpLog);
Helpers.StringTraceLine(viewGenResults.ErrorsToString());
return(viewGenResults);
}
var foreignKeyConstraints = ForeignConstraint.GetForeignConstraints(container);
var partitioner = new CellPartitioner(cells, foreignKeyConstraints);
var cellGroups = partitioner.GroupRelatedCells();
foreach (var cellGroup in cellGroups)
{
ViewGenerator viewGenerator = null;
var groupErrorLog = new ErrorLog();
try
{
viewGenerator = new ViewGenerator(cellGroup, config, foreignKeyConstraints, containerMapping);
}
catch (InternalMappingException exception)
{
// All exceptions have mapping errors in them
Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");
groupErrorLog = exception.ErrorLog;
}
if (groupErrorLog.Count == 0)
{
Debug.Assert(viewGenerator != null);
groupErrorLog = viewGenerator.GenerateAllBidirectionalViews(viewGenResults.Views, identifiers);
}
if (groupErrorLog.Count != 0)
{
viewGenResults.AddErrors(groupErrorLog);
}
}
// We used to print the errors here. Now we trace them as they are being thrown
//if (viewGenResults.HasErrors && config.IsViewTracing) {
// Helpers.StringTraceLine(viewGenResults.ErrorsToString());
//}
return(viewGenResults);
}
