public void TestIPluginCohortCompiler_PopulatesCacheCorrectly()
{
var activator = new ConsoleInputManager(RepositoryLocator, new ThrowImmediatelyCheckNotifier())
{
DisallowInput = true
};
// create a cohort config
var cic = new CohortIdentificationConfiguration(CatalogueRepository, "mycic");
cic.QueryCachingServer_ID = externalDatabaseServer.ID;
cic.SaveToDatabase();
// this special Catalogue will be detected by ExamplePluginCohortCompiler and interpreted as an API call
var myApi = new Catalogue(CatalogueRepository, ExamplePluginCohortCompiler.ExampleAPIName);
// add it to the cohort config
cic.CreateRootContainerIfNotExists();
// create a use of the API as an AggregateConfiguration
var cmd = new ExecuteCommandAddCatalogueToCohortIdentificationSetContainer(activator, new CatalogueCombineable(myApi), cic.RootCohortAggregateContainer);
Assert.IsFalse(cmd.IsImpossible, cmd.ReasonCommandImpossible);
cmd.Execute();
// run the cic
var source = new CohortIdentificationConfigurationSource();
source.PreInitialize(cic, new ThrowImmediatelyDataLoadEventListener());
var dt = source.GetChunk(new ThrowImmediatelyDataLoadEventListener(), new GracefulCancellationToken());
// 5 random chi numbers
Assert.AreEqual(5, dt.Rows.Count);
// test stale
cmd.AggregateCreatedIfAny.Description = "2";
cmd.AggregateCreatedIfAny.SaveToDatabase();
// run the cic again
source = new CohortIdentificationConfigurationSource();
source.PreInitialize(cic, new ThrowImmediatelyDataLoadEventListener());
dt = source.GetChunk(new ThrowImmediatelyDataLoadEventListener(), new GracefulCancellationToken());
// because the rules changed to generate 2 chis only there should be a new result
Assert.AreEqual(2, dt.Rows.Count);
var results = new[] { (string)dt.Rows[0][0], (string)dt.Rows[1][0] };
// run the cic again with no changes, the results should be unchanged since there is no config changed
// I.e. no new chis should be generated and the cached values returned
source = new CohortIdentificationConfigurationSource();
source.PreInitialize(cic, new ThrowImmediatelyDataLoadEventListener());
dt = source.GetChunk(new ThrowImmediatelyDataLoadEventListener(), new GracefulCancellationToken());
Assert.AreEqual(2, dt.Rows.Count);
var results2 = new[] { (string)dt.Rows[0][0], (string)dt.Rows[1][0] };
Assert.AreEqual(results[0], results2[0]);
Assert.AreEqual(results[1], results2[1]);
}
private CohortIdentificationConfiguration CreateCohortIdentificationConfiguration(ExtractionFilter inclusionFilter1)
{
//Create the top level configuration object
var cic = new CohortIdentificationConfiguration(_repos.CatalogueRepository, "Tayside Lung Cancer Cohort");
//create a UNION container for Inclusion Criteria
var container = new CohortAggregateContainer(_repos.CatalogueRepository, SetOperation.UNION);
container.Name = "Inclusion Criteria";
container.SaveToDatabase();
cic.RootCohortAggregateContainer_ID = container.ID;
cic.SaveToDatabase();
//Create a new cohort set to the 'Inclusion Criteria' based on the filters Catalogue
var cata = inclusionFilter1.ExtractionInformation.CatalogueItem.Catalogue;
var ac = cic.CreateNewEmptyConfigurationForCatalogue(cata, (a, b) => { throw new Exception("Problem encountered with chi column(s)"); }, false);
container.AddChild(ac, 0);
//Add the filter to the WHERE logic of the cohort set
var whereContainer = new AggregateFilterContainer(_repos.CatalogueRepository, FilterContainerOperation.OR);
ac.Name = "People with " + inclusionFilter1.Name;
ac.RootFilterContainer_ID = whereContainer.ID;
cic.EnsureNamingConvention(ac); //this will put cicx at the front and cause implicit SaveToDatabase
FilterImporter filterImporter = new FilterImporter(new AggregateFilterFactory(_repos.CatalogueRepository), null);
var cloneFilter = filterImporter.ImportFilter(inclusionFilter1, null);
whereContainer.AddChild(cloneFilter);
return(cic);
}
public CohortIdentificationConfigurationMenu(RDMPContextMenuStripArgs args, CohortIdentificationConfiguration cic) : base(args, cic)
{
_cic = cic;
Items.Add("View SQL", _activator.CoreIconProvider.GetImage(RDMPConcept.SQL), (s, e) => _activator.Activate <ViewCohortIdentificationConfigurationUI, CohortIdentificationConfiguration>(cic));
Items.Add(new ToolStripSeparator());
_executeAndImportCommand = new ExecuteCommandCreateNewCohortByExecutingACohortIdentificationConfiguration(_activator).SetTarget(cic);
Add(_executeAndImportCommand);
//associate with project
Add(new ExecuteCommandAssociateCohortIdentificationConfigurationWithProject(_activator).SetTarget(cic));
Items.Add(new ToolStripSeparator());
_executeCommandClone = new ExecuteCommandCloneCohortIdentificationConfiguration(_activator).SetTarget(cic);
Add(_executeCommandClone);
Add(new ExecuteCommandFreezeCohortIdentificationConfiguration(_activator, cic, !cic.Frozen));
Items.Add(new ToolStripSeparator());
Add(new ExecuteCommandCreateNewCohortIdentificationConfiguration(_activator));
Add(new ExecuteCommandSetQueryCachingDatabase(_activator, cic));
Add(new ExecuteCommandCreateNewQueryCacheDatabase(_activator, cic));
}
public CohortIdentificationConfigurationMenu(RDMPContextMenuStripArgs args, CohortIdentificationConfiguration cic): base(args, cic)
{
_cic = cic;
Items.Add("View SQL", _activator.CoreIconProvider.GetImage(RDMPConcept.SQL), (s, e) => _activator.Activate<ViewCohortIdentificationConfigurationUI, CohortIdentificationConfiguration>(cic));
Items.Add(new ToolStripSeparator());
_executeAndImportCommand = new ExecuteCommandCreateNewCohortByExecutingACohortIdentificationConfiguration(_activator).SetTarget(cic);
Add(_executeAndImportCommand);
//associate with project
Add(new ExecuteCommandAssociateCohortIdentificationConfigurationWithProject(_activator).SetTarget(cic));
Items.Add(new ToolStripSeparator());
_executeCommandClone = new ExecuteCommandCloneCohortIdentificationConfiguration(_activator).SetTarget(cic);
Add(_executeCommandClone);
Add(new ExecuteCommandFreezeCohortIdentificationConfiguration(_activator, cic, !cic.Frozen));
Items.Add(new ToolStripSeparator());
Add(new ExecuteCommandCreateNewCohortIdentificationConfiguration(_activator));
if(_activator.CoreChildProvider is DataExportChildProvider dx)
AddGoTo(()=>dx.AllProjectAssociatedCics.Where(a=>a.CohortIdentificationConfiguration_ID == cic.ID).Select(a=>a.Project).Distinct(),"Project(s)");
}
protected override void SetUp()
{
base.SetUp();
c = new Catalogue(CatalogueRepository, "MyCata");
ci = new CatalogueItem(CatalogueRepository, c, "MyCataItem");
ci2 = new CatalogueItem(CatalogueRepository, c, "YearColumn");
t = new TableInfo(CatalogueRepository, "MyTable");
col = new ColumnInfo(CatalogueRepository, "mycol", "varchar(10)", t);
col2 = new ColumnInfo(CatalogueRepository, "myOtherCol", "varchar(10)", t);
acCohort = new AggregateConfiguration(CatalogueRepository, c, CohortIdentificationConfiguration.CICPrefix + "Agg1_Cohort");
acDataset = new AggregateConfiguration(CatalogueRepository, c, "Agg2_Dataset");
ei_Year = new ExtractionInformation(CatalogueRepository, ci2, col2, "Year");
ei_Year.IsExtractionIdentifier = true;
ei_Year.SaveToDatabase();
acDataset.AddDimension(ei_Year);
acDataset.CountSQL = "count(*)";
acDataset.SaveToDatabase();
ei_Chi = new ExtractionInformation(CatalogueRepository, ci, col, "CHI");
ei_Chi.IsExtractionIdentifier = true;
ei_Chi.SaveToDatabase();
acCohort.AddDimension(ei_Chi);
cic = new CohortIdentificationConfiguration(CatalogueRepository, "mycic");
cic.CreateRootContainerIfNotExists();
cic.RootCohortAggregateContainer.AddChild(acCohort, 0);
}
private void SetupCohort(out DiscoveredDatabase db, out CohortIdentificationConfiguration cic, out DataTable dt)
{
dt = new DataTable();
dt.Columns.Add("PK");
//add lots of rows
for (int i = 0; i < 100000; i++)
{
dt.Rows.Add(i);
}
db = GetCleanedServer(DatabaseType.MicrosoftSQLServer, true);
var tbl = db.CreateTable("CohortCompilerRunnerTestsTable", dt);
var cata = Import(tbl);
var ei = cata.CatalogueItems[0].ExtractionInformation;
ei.IsExtractionIdentifier = true;
ei.SaveToDatabase();
var agg = new AggregateConfiguration(CatalogueRepository, cata, "MyAgg");
agg.CountSQL = null;
agg.SaveToDatabase();
var dimension = new AggregateDimension(CatalogueRepository, ei, agg);
cic = new CohortIdentificationConfiguration(CatalogueRepository, "MyCic");
cic.CreateRootContainerIfNotExists();
cic.RootCohortAggregateContainer.AddChild(agg, 0);
}
public ExecuteCommandCreateNewQueryCacheDatabase(IActivateItems activator, CohortIdentificationConfiguration configuration) : base(activator)
{
_cic = configuration;
if (_cic.QueryCachingServer_ID != null)
{
SetImpossible("CohortIdentificationConfiguration already has a Query Cache configured");
}
}
public JoinableTask(JoinableCohortAggregateConfiguration joinable, CohortCompiler compiler) : base(compiler)
{
Joinable = joinable;
_aggregate = Joinable.AggregateConfiguration;
_cohortIdentificationConfiguration = _aggregate.GetCohortIdentificationConfigurationIfAny();
_catalogueName = Joinable.AggregateConfiguration.Catalogue.Name;
RefreshIsUsedState();
}
public void Join_PatientIndexTable_OptionalCacheOnSameServer(DatabaseType dbType, bool createQueryCache)
{
/*
* Server1
* _____________
* |Biochemistry|
* ↓
* ___________________
* | Cache (optional) |
* ↓ join ↓
* _____________________
* | Hospital Admissions|
*
*/
var db = GetCleanedServer(dbType);
ExternalDatabaseServer cache = null;
if (createQueryCache)
{
cache = CreateCache(db);
}
var r = new Random(500);
var people = new PersonCollection();
people.GeneratePeople(5000, r);
var cic = new CohortIdentificationConfiguration(CatalogueRepository, "cic");
var joinable = SetupPatientIndexTable(db, people, r, cic);
cic.CreateRootContainerIfNotExists();
cic.QueryCachingServer_ID = cache?.ID;
cic.SaveToDatabase();
var hospitalAdmissions = SetupPatientIndexTableUser(db, people, r, cic, joinable);
cic.RootCohortAggregateContainer.AddChild(hospitalAdmissions, 0);
var compiler = new CohortCompiler(cic);
var runner = new CohortCompilerRunner(compiler, 50000);
runner.Run(new CancellationToken());
AssertNoErrors(compiler);
if (createQueryCache)
{
Assert.IsTrue(compiler.Tasks.Any(t => t.Key.GetCachedQueryUseCount().Equals("1/1")), "Expected cache to be used for the joinable");
}
else
{
Assert.IsTrue(compiler.Tasks.Any(t => t.Key.GetCachedQueryUseCount().Equals("0/1")), "Did not create cache so expected cache usage to be 0");
}
}
public void TestSimpleMerge()
{
var merger = new CohortIdentificationConfigurationMerger(CatalogueRepository);
var cic1 = new CohortIdentificationConfiguration(CatalogueRepository, "cic1");
var cic2 = new CohortIdentificationConfiguration(CatalogueRepository, "cic2");
cic1.CreateRootContainerIfNotExists();
var root1 = cic1.RootCohortAggregateContainer;
root1.Name = "Root1";
root1.SaveToDatabase();
root1.AddChild(aggregate1, 1);
cic2.CreateRootContainerIfNotExists();
var root2 = cic2.RootCohortAggregateContainer;
root2.Name = "Root2";
root2.SaveToDatabase();
root2.AddChild(aggregate2, 2);
Assert.AreEqual(1, cic1.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively().Count);
Assert.AreEqual(1, cic2.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively().Count);
int numberOfCicsBefore = CatalogueRepository.GetAllObjects <CohortIdentificationConfiguration>().Count();
var result = merger.Merge(new [] { cic1, cic2 }, SetOperation.UNION);
//original should still be intact
Assert.AreEqual(1, cic1.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively().Count);
Assert.AreEqual(1, cic2.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively().Count);
//the new merged set should contain both
Assert.AreEqual(2, result.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively().Count);
Assert.IsFalse(result.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively().Any(c => c.Equals(aggregate1)), "Expected the merge to include clone aggregates not the originals! (aggregate1)");
Assert.IsFalse(result.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively().Any(c => c.Equals(aggregate2)), "Expected the merge to include clone aggregates not the originals! (aggregate2)");
// Now should be a new one
Assert.AreEqual(numberOfCicsBefore + 1, CatalogueRepository.GetAllObjects <CohortIdentificationConfiguration>().Count());
var newCicId = result.ID;
// Should have the root containers of the old configs
Assert.AreEqual("Root2", result.RootCohortAggregateContainer.GetSubContainers()[0].Name);
Assert.AreEqual("Root1", result.RootCohortAggregateContainer.GetSubContainers()[1].Name);
// And should have
Assert.AreEqual($"cic_{newCicId}_UnitTestAggregate2", result.RootCohortAggregateContainer.GetSubContainers()[0].GetAggregateConfigurations()[0].Name);
Assert.AreEqual($"cic_{newCicId}_UnitTestAggregate1", result.RootCohortAggregateContainer.GetSubContainers()[1].GetAggregateConfigurations()[0].Name);
Assert.AreEqual($"Merged cics (IDs {cic1.ID},{cic2.ID})", result.Name);
Assert.IsTrue(cic1.Exists());
Assert.IsTrue(cic2.Exists());
}
public override void SetDatabaseObject(IActivateItems activator, CohortIdentificationConfiguration databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_configuration = databaseObject;
RebuildClearCacheCommand();
gbCicInfo.Text = $"Name: {_configuration.Name}";
tbDescription.Text = $"Description: {_configuration.Description}";
ticket.TicketText = _configuration.Ticket;
if (_commonFunctionality == null)
{
activator.RefreshBus.Subscribe(this);
_commonFunctionality = new RDMPCollectionCommonFunctionality();
_commonFunctionality.SetUp(RDMPCollection.Cohort, tlvCic, activator, olvNameCol, olvNameCol, new RDMPCollectionCommonFunctionalitySettings
{
SuppressActivate = true,
AddFavouriteColumn = false,
AddCheckColumn = false,
AllowPinning = false,
AllowSorting = true, //important, we need sorting on so that we can override sort order with our OrderableComparer
});
_commonFunctionality.MenuBuilt += MenuBuilt;
tlvCic.AddObject(_configuration);
tlvCic.ExpandAll();
}
CommonFunctionality.AddToMenu(cbIncludeCumulative);
CommonFunctionality.AddToMenu(new ToolStripSeparator());
CommonFunctionality.AddToMenu(new ExecuteCommandSetQueryCachingDatabase(Activator, _configuration));
CommonFunctionality.AddToMenu(new ExecuteCommandClearQueryCache(Activator, _configuration));
CommonFunctionality.AddToMenu(new ExecuteCommandCreateNewQueryCacheDatabase(activator, _configuration));
CommonFunctionality.AddToMenu(
new ExecuteCommandSet(activator, _configuration, _configuration.GetType().GetProperty("Description"))
{
OverrideIcon =
Activator.CoreIconProvider.GetImage(RDMPConcept.CohortIdentificationConfiguration, OverlayKind.Edit)
});
CommonFunctionality.AddToMenu(new ToolStripSeparator());
CommonFunctionality.AddToMenu(new ExecuteCommandShowXmlDoc(activator, "CohortIdentificationConfiguration.QueryCachingServer_ID", "Query Caching"), "Help (What is Query Caching)");
CommonFunctionality.Add(new ExecuteCommandCreateNewCohortByExecutingACohortIdentificationConfiguration(activator, null).SetTarget(_configuration),
"Commit Cohort",
activator.CoreIconProvider.GetImage(RDMPConcept.ExtractableCohort, OverlayKind.Add));
foreach (var c in _timeoutControls.GetControls())
{
CommonFunctionality.Add(c);
}
_queryCachingServer = _configuration.QueryCachingServer;
Compiler.CohortIdentificationConfiguration = _configuration;
Compiler.CoreChildProvider = activator.CoreChildProvider;
RecreateAllTasks();
}
/// <summary>
/// Returns all <see cref="AggregateConfiguration"/> from the <paramref name="arg"/> where the dataset is the same and there are filters defined
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private IEnumerable <AggregateConfiguration> GetEligibleChildren(CohortIdentificationConfiguration arg)
{
if (arg.RootCohortAggregateContainer_ID == null)
{
return(new AggregateConfiguration[0]);
}
return(arg.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively()
.Where(ac => ac.Catalogue_ID == _catalogue.ID && ac.RootFilterContainer_ID != null));
}
public AggregateConfigurationCombineable GenerateAggregateConfigurationFor(IBasicActivateItems activator,
CohortIdentificationConfiguration cic, bool importMandatoryFilters = true,
[CallerMemberName] string caller = null)
{
var newAggregate = cic.CreateNewEmptyConfigurationForCatalogue(Catalogue,
ResolveMultipleExtractionIdentifiers ??
((a,b)=> CohortCombineToCreateCommandHelper.PickOneExtractionIdentifier(activator,a, b)),
importMandatoryFilters);
return new AggregateConfigurationCombineable(newAggregate);
}
private ParameterCollectionUIOptions Create(CohortIdentificationConfiguration cohortIdentificationConfiguration, ICoreChildProvider coreChildProvider)
{
var builder = new CohortQueryBuilder(cohortIdentificationConfiguration, coreChildProvider);
builder.RegenerateSQL();
var paramManager = builder.ParameterManager;
return(new ParameterCollectionUIOptions(UseCaseCohortIdentificationConfiguration, cohortIdentificationConfiguration, ParameterLevel.Global, paramManager));
}
private void btnGo_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(tbName.Text))
{
MessageBox.Show("Enter a name for your Cohort Identification Criteria");
return;
}
if (!Activator.YesNo("Are you sure you are happy with your configuration, this wizard will close after creating?", "Confirm"))
{
return;
}
var cic = new CohortIdentificationConfiguration(Activator.RepositoryLocator.CatalogueRepository, tbName.Text);
cic.CreateRootContainerIfNotExists();
var root = cic.RootCohortAggregateContainer;
root.Operation = SetOperation.EXCEPT;
root.Name = "EXCEPT";
root.SaveToDatabase();
var includeContainer = setOperationInclude.CreateCohortAggregateContainer(root);
inclusionCriteria1.CreateCohortSet(cic, includeContainer, 1);
if (cbInclusion2.Checked)
{
inclusionCriteria2.CreateCohortSet(cic, includeContainer, 2);
}
if (cbExclusion1.Checked || cbExclusion2.Checked)
{
var excludeContainer = setOperationExclude.CreateCohortAggregateContainer(root);
if (cbExclusion1.Checked)
{
exclusionCriteria1.CreateCohortSet(cic, excludeContainer, 1);
}
if (cbExclusion2.Checked)
{
exclusionCriteria2.CreateCohortSet(cic, excludeContainer, 2);
}
}
Activator.RefreshBus.Publish(this, new RefreshObjectEventArgs(cic));
CohortIdentificationCriteriaCreatedIfAny = cic;
DialogResult = DialogResult.OK;
Close();
}
public override IAtomicCommandWithTarget SetTarget(DatabaseEntity target)
{
base.SetTarget(target);
if (target is CohortIdentificationConfiguration)
{
_cic = (CohortIdentificationConfiguration)target;
}
return(this);
}
void OnImportCompletedSuccessfully(object sender, PipelineEngineEventArgs u, CohortIdentificationConfiguration cic)
{
//see if we can associate the cic with the project
var cmd = new ExecuteCommandAssociateCohortIdentificationConfigurationWithProject(BasicActivator).SetTarget((Project)Project).SetTarget(cic);
//we can!
if (!cmd.IsImpossible)
{
cmd.Execute();
}
}
public ExecuteCommandSetQueryCachingDatabase(IBasicActivateItems activator, CohortIdentificationConfiguration cic) : base(activator)
{
_cic = cic;
_caches = BasicActivator.RepositoryLocator.CatalogueRepository.GetAllObjects <ExternalDatabaseServer>()
.Where(s => s.WasCreatedBy(new QueryCachingPatcher())).ToArray();
if (!_caches.Any())
{
SetImpossible("There are no Query Caching databases set up");
}
}
public void TestImportTree_FromCohortIdentificationConfiguration_ToSelectedDatasets_PreserveOperation()
{
var sds = WhenIHaveA <SelectedDataSets>();
var cata = sds.ExtractableDataSet.Catalogue;
var cic = new CohortIdentificationConfiguration(Repository, "my cic");
cic.CreateRootContainerIfNotExists();
var ac = new AggregateConfiguration(Repository, cata, "myagg");
ac.CreateRootContainerIfNotExists();
cic.RootCohortAggregateContainer.AddChild(ac, 1);
var filterToImport = new AggregateFilter(Repository, "MyFilter")
{
WhereSQL = "true"
};
var root = ac.RootFilterContainer;
root.AddChild(filterToImport);
root.Operation = FilterContainerOperation.OR;
root.SaveToDatabase();
// add 2 subcontainers, these should also get cloned and should preserve the Operation correctly
root.AddChild(new AggregateFilterContainer(Repository, FilterContainerOperation.AND));
root.AddChild(new AggregateFilterContainer(Repository, FilterContainerOperation.OR));
//there should be no root container
Assert.IsNull(sds.RootFilterContainer);
//run the command
var mgr = new ConsoleInputManager(RepositoryLocator, new ThrowImmediatelyCheckNotifier());
mgr.DisallowInput = true;
var cmd = new ExecuteCommandImportFilterContainerTree(mgr, sds, ac);
Assert.IsFalse(cmd.IsImpossible, cmd.ReasonCommandImpossible);
cmd.Execute();
sds.ClearAllInjections();
Assert.AreEqual(FilterContainerOperation.OR, sds.RootFilterContainer.Operation);
Assert.IsNotNull(sds.RootFilterContainer);
Assert.AreEqual(1, sds.RootFilterContainer.GetFilters().Length);
var subContainers = sds.RootFilterContainer.GetSubContainers();
Assert.AreEqual(2, subContainers.Length);
Assert.AreEqual(1, subContainers.Count(e => e.Operation == FilterContainerOperation.AND));
Assert.AreEqual(1, subContainers.Count(e => e.Operation == FilterContainerOperation.OR));
}
public AggregationTask(AggregateConfiguration aggregate, CohortCompiler compiler) : base(compiler)
{
Aggregate = aggregate;
_catalogueName = aggregate.Catalogue.Name;
_cohortIdentificationConfiguration = compiler.CohortIdentificationConfiguration;
var container = aggregate.GetCohortAggregateContainerIfAny();
if (container != null)
{
_allParentContainers = container.GetAllParentContainers().ToList();
_allParentContainers.Add(container);
}
}
public void TestOrphanCic()
{
var memory = new MemoryDataExportRepository();
var cic = new CohortIdentificationConfiguration(memory, "Mycic");
var p = new Project(memory, "my proj");
p.AssociateWithCohortIdentification(cic);
//fetch the instance
var cicAssoc = memory.GetAllObjects <ProjectCohortIdentificationConfigurationAssociation>().Single();
//relationship from p should resolve to the association link
Assert.AreEqual(cicAssoc, p.ProjectCohortIdentificationConfigurationAssociations[0]);
//relationship from p should resolve to the cic
Assert.AreEqual(cic, p.GetAssociatedCohortIdentificationConfigurations()[0]);
//in order to make it an orphan we have to suppress the system default behaviour of cascading across the deletion
var obscure = memory.ObscureDependencyFinder as CatalogueObscureDependencyFinder;
if (obscure != null)
{
obscure.OtherDependencyFinders.Clear();
}
//make the assoc an orphan
cic.DeleteInDatabase();
cicAssoc.ClearAllInjections();
//assoc should still exist
Assert.AreEqual(cicAssoc, p.ProjectCohortIdentificationConfigurationAssociations[0]);
Assert.IsNull(p.ProjectCohortIdentificationConfigurationAssociations[0].CohortIdentificationConfiguration);
//relationship from p should resolve to the cic
Assert.IsEmpty(p.GetAssociatedCohortIdentificationConfigurations());
//error should be reported in top right of program
var ex = Assert.Throws <Exception>(() => new DataExportChildProvider(new RepositoryProvider(memory), null, new ThrowImmediatelyCheckNotifier(), null));
StringAssert.IsMatch(@"Failed to find Associated Cohort Identification Configuration with ID \d+ which was supposed to be associated with my proj", ex.Message);
//but UI should still respond
var childProvider = new DataExportChildProvider(new RepositoryProvider(memory), null, new IgnoreAllErrorsCheckNotifier(), null);
//the orphan cic should not appear in the tree view under Project=>Cohorts=>Associated Cics
var cohorts = childProvider.GetChildren(p).OfType <ProjectCohortsNode>().Single();
var cics = childProvider.GetChildren(cohorts).OfType <ProjectCohortIdentificationConfigurationAssociationsNode>().First();
Assert.IsEmpty(childProvider.GetChildren(cics));
}
public IAtomicCommandWithTarget SetTarget(DatabaseEntity target)
{
if (target is CohortIdentificationConfiguration)
{
_cic = (CohortIdentificationConfiguration)target;
}
if (target is Project)
{
_project = (Project)target;
}
return(this);
}
public void CreateCohortSet(CohortIdentificationConfiguration cic, CohortAggregateContainer targetContainer, int order)
{
var cata = cbxCatalogues.SelectedItem as Catalogue;
if (cata == null)
{
throw new Exception("Catalogue has not been picked!");
}
var cataCommand = new CatalogueCombineable(cata);
//use this one
cataCommand.ResolveMultipleExtractionIdentifiers = (s, e) => cbxColumns.SelectedItem as ExtractionInformation;
var cmd = new ExecuteCommandAddCatalogueToCohortIdentificationSetContainer(_activator, cataCommand, targetContainer);
cmd.SkipMandatoryFilterCreation = true;
cmd.Execute();
var aggregate = cmd.AggregateCreatedIfAny;
var filterOp = (FilterContainerOperation)ddAndOr.SelectedItem;
IContainer filterContainer;
if (aggregate.RootFilterContainer_ID != null)
{
//this is the case if there are mandatory filters in the dataset
filterContainer = aggregate.RootFilterContainer;
filterContainer.Operation = filterOp;
filterContainer.SaveToDatabase();
}
else
{
filterContainer = new AggregateFilterContainer(_activator.RepositoryLocator.CatalogueRepository, filterOp);
}
aggregate.Order = order;
aggregate.RootFilterContainer_ID = filterContainer.ID;
aggregate.SaveToDatabase();
List <IFilter> filtersAddedSoFar = new List <IFilter>();
foreach (var ui in _filterUIs)
{
var f = ui.CreateFilter(new AggregateFilterFactory(_activator.RepositoryLocator.CatalogueRepository), filterContainer, filtersAddedSoFar.ToArray());
filtersAddedSoFar.Add(f);
}
}
public ExecuteCommandCreateNewCohortByExecutingACohortIdentificationConfiguration(IBasicActivateItems activator,
[DemandsInitialization("The cohort builder query that should be executed")]
CohortIdentificationConfiguration cic,
[DemandsInitialization(Desc_ExternalCohortTableParameter)]
ExternalCohortTable ect,
[DemandsInitialization(Desc_CohortNameParameter)]
string cohortName,
[DemandsInitialization(Desc_ProjectParameter)]
Project project,
[DemandsInitialization("Pipeline for executing the query, performing any required transforms on the output list and allocating release identifiers")]
IPipeline pipeline) :
base(activator, ect, cohortName, project, pipeline)
{
_cic = cic;
}
public void Join_PatientIndexTable_DoNotUseCacheOnDifferentServer(DatabaseType dbType)
{
/*
* Server1 Server 2
* _____________ _________
* |Biochemistry| → | Cache | (cache is still populated but not used in the resulting join).
*
* ↓ join ↓ (do not use cache)
* _____________________
* | Hospital Admissions|
*
*/
//get the data database
var db = GetCleanedServer(dbType);
//create the cache on the other server type (doesn't matter what type just as long as it's different).
var dbCache =
GetCleanedServer(Enum.GetValues(typeof(DatabaseType)).Cast <DatabaseType>().First(t => t != dbType));
ExternalDatabaseServer cache = CreateCache(dbCache);
var r = new Random(500);
var people = new PersonCollection();
people.GeneratePeople(5000, r);
var cic = new CohortIdentificationConfiguration(CatalogueRepository, "cic");
var joinable = SetupPatientIndexTable(db, people, r, cic);
cic.CreateRootContainerIfNotExists();
cic.QueryCachingServer_ID = cache?.ID;
cic.SaveToDatabase();
var hospitalAdmissions = SetupPatientIndexTableUser(db, people, r, cic, joinable);
cic.RootCohortAggregateContainer.AddChild(hospitalAdmissions, 0);
var compiler = new CohortCompiler(cic);
var runner = new CohortCompilerRunner(compiler, 50000);
runner.Run(new CancellationToken());
AssertNoErrors(compiler);
Assert.IsTrue(compiler.Tasks.Any(t => t.Key.GetCachedQueryUseCount().Equals("1/1")), "Expected cache to be used only for the final UNION");
}
public override void SetDatabaseObject(IActivateItems activator, CohortIdentificationConfiguration databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
if (btnUseCache == null)
{
btnUseCache = new ToolStripButton("Use Cache (if available)");
btnUseCache.CheckOnClick = true;
btnUseCache.Checked = databaseObject.QueryCachingServer_ID.HasValue;
btnUseCache.CheckedChanged += (s, e) => GenerateQuery();
}
btnUseCache.Enabled = databaseObject.QueryCachingServer_ID.HasValue;
CommonFunctionality.Add(btnUseCache);
GenerateQuery();
}
public override void SetDatabaseObject(IActivateItems activator, CohortIdentificationConfiguration databaseObject)
{
_cic = databaseObject;
base.SetDatabaseObject(activator, databaseObject);
foreach (var c in _timeoutControls.GetControls())
{
CommonFunctionality.Add(c);
}
_queryCachingServer = _cic.QueryCachingServer;
Compiler.CohortIdentificationConfiguration = _cic;
CoreIconProvider = activator.CoreIconProvider;
RecreateAllTasks();
}
public ExecuteCommandConvertAggregateConfigurationToPatientIndexTable(IActivateItems activator, AggregateConfigurationCommand sourceAggregateConfigurationCommand, CohortIdentificationConfiguration cohortIdentificationConfiguration) : base(activator)
{
_sourceAggregateConfigurationCommand = sourceAggregateConfigurationCommand;
_cohortIdentificationConfiguration = cohortIdentificationConfiguration;
if (sourceAggregateConfigurationCommand.JoinableDeclarationIfAny != null)
{
SetImpossible("Aggregate is already a Patient Index Table");
}
if (_sourceAggregateConfigurationCommand.CohortIdentificationConfigurationIfAny != null &&
_sourceAggregateConfigurationCommand.CohortIdentificationConfigurationIfAny.ID != _cohortIdentificationConfiguration.ID)
{
SetImpossible("Aggregate '" + _sourceAggregateConfigurationCommand.Aggregate + "' belongs to a different Cohort Identification Configuration");
}
}
/// <summary>
/// Adds all subqueries and containers that are below the current CohortIdentificationConfiguration as tasks to the compiler
/// </summary>
/// <param name="addSubcontainerTasks">The root container is always added to the task list but you could skip subcontainer totals if all you care about is the final total for the cohort
/// and you don't have a dependant UI etc. Passing false will add all joinables, subqueries etc and the root container (final answer for who is in cohort) only.</param>
/// <returns></returns>
public List <ICompileable> AddAllTasks(bool addSubcontainerTasks = true)
{
var toReturn = new List <ICompileable>();
var globals = CohortIdentificationConfiguration.GetAllParameters();
CohortIdentificationConfiguration.CreateRootContainerIfNotExists();
foreach (var joinable in CohortIdentificationConfiguration.GetAllJoinables())
{
toReturn.Add(AddTask(joinable, globals));
}
toReturn.AddRange(AddTasksRecursively(globals, CohortIdentificationConfiguration.RootCohortAggregateContainer, addSubcontainerTasks));
return(toReturn);
}
public override bool ShowCohortWizard(out CohortIdentificationConfiguration cic)
{
var wizard = new CreateNewCohortIdentificationConfigurationUI(this);
if (wizard.ShowDialog() == DialogResult.OK)
{
cic = wizard.CohortIdentificationCriteriaCreatedIfAny;
}
else
{
cic = null;
}
// Wizard was shown so that's a thing
return(true);
}
