/// <summary>
/// NextTargetUnpivotedCombinedRow
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
public UnpivotedAssayResult NextTargetUnpivotedCombinedRow(
Query q)
{
UnpivotedAssayResult rr = new UnpivotedAssayResult();
return(rr);
}
/// <summary>
/// Retrieve next result row
/// </summary>
/// <returns></returns>
public override object[] NextRow()
{
object[] vo;
UnpivotedAssayResult rr;
if (!PivotInCode) // if not multipivot then call generic broker
{
vo = base.NextRow();
}
else if (MultipivotRowList == null || MultipivotRowList.Count == 0)
{
vo = null;
}
else // remove row from multipivot row list
{
vo = MultipivotRowList[0]; // note: iterating MultipivotRowDict is slow
MultipivotRowList.RemoveAt(0);
}
if (vo != null)
{
rr = UnpivotedAssayResult.FromValueObjectNew(vo, MdbAssayVoMap); // set cond formatting
rr.SetResultValueBackColor(rr.ResultValue, rr.ActivityBin);
rr.SetResultValueBackColor(rr.MostPotentVal, rr.ActivityBinMostPotent);
SetCoordinates(rr);
int voLength = Qt.SelectedCount;
//if (vo.Length == voLength)
rr.ToValueObject(vo, MdbAssayVoMap); // if same length use existing vo
}
return(vo);
}
/// <summary>
/// Set coords based on gene symbol & current target map
/// </summary>
/// <param name="rr"></param>
void SetCoordinates(UnpivotedAssayResult rr)
{
UnpivotedAssayResult rr2;
int tci;
if (TargetMap == null || !TargetMap.Coords.ContainsKey(rr.GeneId))
{
return;
}
//if (rr.TargetSymbol != "CHRM5") rr = rr; // debug
List <TargetMapCoords> coordList = TargetMap.Coords[rr.GeneId];
for (tci = 0; tci < coordList.Count; tci++)
{
if (tci == 0)
{
rr2 = rr;
}
else
{
rr2 = rr.CloneUnpivotedAssayResult();
}
TargetMapCoords tmc = coordList[tci];
rr2.TargetMapX = tmc.X;
rr2.TargetMapY = -tmc.Y; // use negative value for y
if (tci > 0)
{
BufferedRows.Add(rr2); // add to buffer
}
}
}
/// <summary>
/// Build summarization detail query
/// </summary>
/// <param name="mt"></param>
/// <param name="mc"></param>
/// <param name="level"></param>
/// <param name="linkInfo"></param>
/// <returns></returns>
public override Query GetDrilldownDetailQuery(
MetaTable mt,
MetaColumn mc,
int level,
string linkInfo)
{
QueryTable qt, qt2;
MetaTable mt2;
QueryColumn qc, qc2;
MetaColumn mc2;
string resultIdColName = "";
Query q = new Query();
// Summarized MdbAssay table drilling down to unsummarized MdbAssay table
if (UnpivotedAssayResult.IsSummarizedMdbAssayTable(mt.Name))
{
if (UnpivotedAssayResult.IsCombinedMdbAssayTable(mt.Name)) // multiple tables
{
mt2 = MetaTableCollection.GetWithException(MultiDbAssayDataNames.CombinedNonSumTableName);
resultIdColName = MultiDbAssayDataNames.SumResultId;
}
else // base unpivoted or pivoted by target
{
mt2 = MetaTableCollection.GetWithException(MultiDbAssayDataNames.BaseNonSumTableName);
resultIdColName = MultiDbAssayDataNames.BaseSumResultId;
}
qt = new QueryTable(q, mt2);
qc = qt.GetQueryColumnByNameWithException(resultIdColName);
qc.Criteria = resultIdColName + " = " + linkInfo;
return(q);
}
// Drilling down from old all_bioassay_unpivoted to specific source data
else if (Lex.Eq(mt.Name, UnpivotedAssayView.UnsummarizedMetaTableName))
{ // ResultId is formatted by the source with the first item being the source name
Match m = Regex.Match(linkInfo, @"(.*),(.*),(.*)", RegexOptions.IgnoreCase | RegexOptions.RightToLeft);
string mtName = m.Groups[1].Value;
string mcId = m.Groups[2].Value;
string linkInfo2 = m.Groups[3].Value;
mt2 = MetaTableCollection.GetWithException(mtName);
IMetaBroker imb = MetaBrokerUtil.GlobalBrokers[(int)mt2.MetaBrokerType];
q = imb.GetDrilldownDetailQuery(mt2, mcId, level, linkInfo2);
return(q);
}
else
{
throw new ArgumentException("Invalid tableName: " + mt.Name);
}
}
/// <summary>
/// Build condformatting for activity bins
/// </summary>
void BuildActivityBinCondFormat()
{
QueryColumn qc;
qc = Qt.GetQueryColumnByName(MultiDbAssayDataNames.ActivityBin); // assign default cond formatting for activity bin
if (qc != null && qc.Selected && qc.CondFormat == null)
{
qc.CondFormat = UnpivotedAssayResult.BuildActivityBinCondFormat();
}
qc = Qt.GetQueryColumnByName(MultiDbAssayDataNames.ActivityBinMostPotent);
if (qc != null && qc.Selected && qc.CondFormat == null)
{
qc.CondFormat = UnpivotedAssayResult.BuildActivityBinCondFormat();
}
return;
}
/// <summary>
/// SetupActivityClassCondFormat
/// </summary>
/// <param name="tableName"></param>
void SetupActivityClassCondFormat(string tableName)
{
QueryTable qt = BaseQuery.GetQueryTableByName(tableName);
if (qt == null)
{
return;
}
QueryColumn qc = qt.GetQueryColumnByName("ACTIVITY_CLASS");
if (qc != null && qc.Selected)
{
qc.CondFormat = UnpivotedAssayResult.BuildActivityClassCondFormat();
}
qc = qt.GetQueryColumnByName("ACTIVITY_BIN");
if (qc != null && qc.Selected)
{
qc.CondFormat = UnpivotedAssayResult.BuildActivityClassCondFormat();
}
return;
}
/// <summary>
/// Display cell text as hyperlinks to allow drilldown
/// Also, set the background color if appropriate (e.g. bin that an SP/CRC value is in)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Grid_CustomAppearance(object sender, PivotCustomAppearanceEventArgs e)
{
e.Appearance.Font = new Font(e.Appearance.Font, FontStyle.Underline);
e.Appearance.ForeColor = Color.Blue;
PivotGridFieldContext f = GetPivotGridFieldContext(e.DataField);
if (f == null)
{
return;
}
ResultsField rfld = f.ResultsField;
if (rfld == null)
{
return;
}
Mobius.Data.QueryColumn qc = rfld.QueryColumn;
MetaColumn mc = qc.MetaColumn;
CondFormat cf = f.Qc.CondFormat;
//if (cf == null || cf.Rules.Count == 0) return;
object cv = e.GetCellValue(e.ColumnIndex, e.RowIndex);
double d = -1;
if (cv is int)
{
d = (int)cv;
}
else if (cv is double)
{
d = (double)cv;
}
else
{
return;
}
if (Math.Abs(1) == 2) // for compound by target
{
if (d >= 1 && d <= 10)
{ // todo: set proper color
Color c = UnpivotedAssayResult.CalculateBinColor((int)d);
e.Appearance.BackColor = c;
}
}
if (DebugMx.False) // color by count
{
d = d / 45;
if (d > 10)
{
d = 10;
}
if (d < 1)
{
d = 1;
}
if (d >= 1 && d <= 10)
{ // todo: set proper color
Color c = UnpivotedAssayResult.CalculateBinColor((int)d);
e.Appearance.BackColor = c;
}
}
if (DebugMx.False) // for bin by target
{
PivotGridField[] rowFields = e.GetRowFields();
if (d > 0 && rowFields.Length > 0)
{
object rfv = e.GetFieldValue(rowFields[0]);
if (rfv == null)
{
return;
}
else if (rfv is int)
{
Color c = UnpivotedAssayResult.CalculateBinColor((int)rfv);
e.Appearance.BackColor = c;
}
}
}
}
/// <summary>
/// Build aggregation type menu for specific field
/// </summary>
/// <param name="qc"></param>
/// <returns></returns>
public ContextMenuStrip SetupAggregationTypeMenu(
QueryColumn qc,
AggregationDef ad,
AggregationTypeChangedDelegate typeDelegate = null,
bool includeGroupingItems = true,
bool includeSummaryItems = true)
{
Qc = qc; // save call parms
Qt = qc.QueryTable;
AggregationDef = ad;
AggregationChangedDelegate = typeDelegate;
MetaColumn mc = Qc.MetaColumn;
// Set Visibility for menu items as appropriate for data type and args
InitMenuItems();
if (includeGroupingItems)
{
GroupByHeaderMenuItem.Available =
AggregationSeparator1.Available = true;
}
if (includeSummaryItems) // summary types allowed for all data types
{
SummarizationHeaderMenuItem.Available =
AggregationSeparator1.Available =
CountMenuItem.Available =
CountDistinctMenuItem.Available =
MinMenuItem.Available =
MaxMenuItem.Available =
MedianMenuItem.Available =
ModeMenuItem.Available =
ConcatenateMenuItem.Available =
ConcatenateDistinctMenuItem.Available =
AggregationSeparator2.Available = true;
}
if (mc.IsKey)
{
if (includeGroupingItems)
{
MatchingValuesMenuItem.Available = true;
}
}
else if (mc.DataType == MetaColumnType.String)
{
if (includeGroupingItems)
{
MatchingValuesMenuItem.Available =
FirstLetterMenuItem.Available = true;
}
}
else if (mc.IsNumeric)
{
if (includeGroupingItems)
{
MatchingValuesMenuItem.Available =
NumericIntervalMenuItem.Available = true;
}
if (includeSummaryItems)
{
SumMenuItem.Available = true;
ArithmeticMeanMenuItem.Available =
GeometricMeanMenuItem.Available = true;
if (UnpivotedAssayResult.IsSpAndCrcUnpivotedAssayResultColumn(mc)) // col contains both SP and CRC values
{
MostPotentMenuItem.Available =
ResultMeanMenuItem.Available = true;
ArithmeticMeanMenuItem.Available =
GeometricMeanMenuItem.Available = false;
}
}
}
else if (mc.DataType == MetaColumnType.Date)
{
if (includeGroupingItems)
{
GroupByDateMenuItem.Available =
QuarterYearMenuItem.Available =
MonthYearMenuItem.Available =
GroupByYearMenuItem.Available = true;
}
}
else if (mc.DataType == MetaColumnType.Structure) // no grouping, count only for summary for now
{
InitMenuItems();
if (includeGroupingItems)
{
//GroupByHeaderMenuItem.Available =
//AggregationSeparator1.Available = true;
includeGroupingItems = false; // todo, grouping on frag
}
if (includeSummaryItems)
{
SummarizationHeaderMenuItem.Available =
CountMenuItem.Available =
AggregationSeparator2.Available = true;
}
}
else if (mc.DataType == MetaColumnType.Image) // no grouping, count only for summary
{
InitMenuItems();
if (includeGroupingItems)
{
includeGroupingItems = false; // not allowed
}
if (includeSummaryItems) // summary types allowed for all data types
{
SummarizationHeaderMenuItem.Available =
CountMenuItem.Available =
AggregationSeparator2.Available = true;
}
}
else // other types
{
if (includeGroupingItems)
{
MatchingValuesMenuItem.Available = true;
}
if (includeSummaryItems)
{
NumberQualifierMenuItem.Available = Qc.IsPotentialNumberQualifier;
}
//SingleValueMenuItem.Available = true; // (Not currently used)
}
if (!includeGroupingItems || !includeSummaryItems)
{
AggregationSeparator1.Available = AggregationSeparator2.Available = false;
}
// Checkmark current selection
string typeName = ad.TypeName;
foreach (ToolStripItem tsi in AggTypeMenu.Items)
{
ToolStripMenuItem tsmi = tsi as ToolStripMenuItem;
if (tsmi == null)
{
continue; // separator of other non-ToolStripMenuItem
}
string menuItemTypeName = tsmi.Tag != null?tsmi.Tag.ToString() : "<null>";
if (Lex.Eq(menuItemTypeName, typeName))
{
tsmi.Checked = true;
}
else
{
tsmi.Checked = false;
}
}
return(AggTypeMenu);
}
/// <summary>
/// Summarize unpivoted unsummarized assay data by target
/// </summary>
/// <param name="parms"></param>
/// <param name="qm2"></param>
/// <returns></returns>
public QueryManager SummarizeByTargetUnpivoted(
TargetSummaryOptions summaryOptions,
QueryManager qm2)
{
// This method takes an unpivoted input query, summarizes it according to the summarization parameters
// and then formats the summarized data according to the specified output format.
// If a targetMap is specified then then coordinates are included in the output, the summarization
// level must be target, and the output format must be unpivoted.
QueryTable qt, qt2;
DataRowMx dr, dr2;
DataRowAttributes dra;
string cid = "", currentCid;
int rti, rfi;
AssayDict tad = TargetAssayDict; // be sure target assay dict has been loaded
TargetAssaySummarizationLevel sumLevel = TargetAssaySummarizationLevel.Target; // target level
SummarizationType sumMethod = summaryOptions.UseMeans ? SummarizationType.BioResponseMean : SummarizationType.MostPotent;
OutputDest outputDest = OutputDest.WinForms;
TargetMap targetMap = TargetMapDao.GetMapWithCoords(summaryOptions.TargetMapName);
qt = Query.GetQueryTableByName(MultiDbAssayDataNames.CombinedNonSumTableName);
if (qt == null)
{
throw new Exception("Query table not found: " + MultiDbAssayDataNames.CombinedNonSumTableName);
}
UnpivotedAssayResultFieldPositionMap voMap = UnpivotedAssayResultFieldPositionMap.NewOriginalMap(); // used for fast indexing of value by col name
voMap.InitializeFromQueryTableVoPositions(qt, 0);
if (qm2 == null) // need to create query manager?
{
qm2 = new QueryManager();
qm2 = InitializeSubqueryQm(MultiDbAssayDataNames.CombinedNonSumTableName);
}
Query q2 = qm2.Query;
qt2 = q2.GetQueryTableByNameWithException(MultiDbAssayDataNames.BaseTableName);
UnpivotedAssayResultFieldPositionMap voMap2 = UnpivotedAssayResultFieldPositionMap.NewOriginalMap(); // used for fast indexing of value by col name
voMap2.InitializeFromQueryTableVoPositions(qt2, 0);
// Summarize rows & store in DataSet
qm2.DataTable.Clear();
Dictionary <string, object> includedTargets = null;
if (summaryOptions.TargetsWithActivesOnly)
{ // scan data & make a list of targets to be included
includedTargets = new Dictionary <string, object>();
// ...
}
List <UnpivotedAssayResult> tars = new List <UnpivotedAssayResult>(); // build list of TA rows here
currentCid = "";
for (int dri = 0; dri <= DataTableMx.Rows.Count; dri++)
{
if (dri < DataTableMx.Rows.Count)
{
dr = DataTableMx.Rows[dri];
cid = dr[KeyValueVoPos] as string;
dra = GetRowAttributes(dr);
if (dra != null && dra.Filtered)
{
continue;
}
if (currentCid == "")
{
currentCid = cid;
}
}
else
{
dr = null;
}
if (dr == null || cid != currentCid)
{ // summarize rows for current cid & add to new datatable
if (tars.Count > 0) //
{
List <UnpivotedAssayResult> sumTars = TargetAssayUtil.SummarizeData(
tars,
sumLevel,
sumMethod,
true,
NullValue.NullNumber,
NullValue.NullNumber,
targetMap);
int voLength2 = qm2.DataTable.Columns.Count;
foreach (UnpivotedAssayResult sumTar in sumTars)
{
object[] vo2 = sumTar.ToValueObject(voLength2, voMap2);
dr2 = qm2.DataTable.NewRow();
dr2.ItemArrayRef = vo2; // copy ref for efficiency since vo won't be changed
qm2.DataTable.Rows.Add(dr2);
}
}
if (dr == null)
{
break;
}
tars.Clear();
currentCid = cid;
}
UnpivotedAssayResult tar = UnpivotedAssayResult.FromValueObjectNew(dr.ItemArray, voMap);
tars.Add(tar); // store in form for summarization
}
qm2.DataTableManager.InitializeRowAttributes();
return(qm2);
}
public static string Databases = "All"; // list of databases to search
/// <summary>
/// Return true if table name is a summarized multidatabase assay table
/// </summary>
/// <param name="mtName"></param>
/// <returns></returns>
public bool IsSummarizedMdbAssayTable(string mtName)
{
return(UnpivotedAssayResult.IsSummarizedMdbAssayTable(mtName));
}
/// <summary>
/// Setup/configure any needed secondary metabroker
/// </summary>
/// <param name="eqp"></param>
/// <param name="mpd"></param>
/// <param name="unpivotedTableIsFirst"></param>
void SetupSecondaryMetaBroker(
ExecuteQueryParms eqp,
MultiTablePivotBrokerTypeData mpd,
out bool unpivotedTableIsFirst)
{
QueryEngine qe2;
Query q2;
QueryTable qt2;
QueryColumn qc2;
MetaTable mt2;
string firstMtName = mpd.FirstTableName;
MetaTable firstMt = MetaTableCollection.GetWithException(firstMtName);
unpivotedTableIsFirst = UnpivotedAssayResult.IsUnpivotedSummarizedMdbAssayTable(firstMtName);
if (unpivotedTableIsFirst) // just use unpivoted table as is
{
SecondaryMetaBroker = this;
Eqp2 = eqp;
}
else // all pivoted tables, create secondary query on the summarized unpivoted table
{
if (SecondaryMetaBroker == null)
{
MultiDbAssayMetaBroker mb2 = SecondaryMetaBroker = new MultiDbAssayMetaBroker();
if (UnpivotedAssayResult.IsCombinedMdbAssayTable(firstMtName))
{
mt2 = MetaTableCollection.GetWithException(MultiDbAssayDataNames.CombinedTableName);
}
else
{
mt2 = MetaTableCollection.GetWithException(MultiDbAssayDataNames.BaseTableName);
}
q2 = new Query();
qt2 = new QueryTable(mt2);
qc2 = qt2.GetQueryColumnByNameWithException(MultiDbAssayDataNames.GeneSymbol);
if (mpd.TableCodeCsvList.Length != 0) // limit by codes
{
qc2.Criteria = qc2.CriteriaDisplay = MultiDbAssayDataNames.GeneSymbol + " in (" + mpd.TableCodeCsvList + ")";
}
q2.AddQueryTable(qt2);
qe2 = new QueryEngine();
qe2.Query = q2;
Eqp2 = new ExecuteQueryParms(qe2, qt2);
mb2.PrepareQuery(Eqp2);
mb2.Sql += " where " + qc2.Criteria;
}
Eqp2.SearchKeySubset = eqp.SearchKeySubset;
}
return;
}
/// <summary>
/// Execute query in preparation for retrieving rows
/// </summary>
/// <param name="parms"></param>
public override void ExecuteQuery(
ExecuteQueryParms eqp)
{
BufferedRows = new List <UnpivotedAssayResult>();
MultiTablePivotBrokerTypeData mpd = null;
MetaTable mt;
List <MultiDbAssayMetaBroker> mbList = null;
MultiDbAssayMetaBroker mb, mb2 = null;
UnpivotedAssayResult rr, rr2;
List <UnpivotedAssayResult> rrList = new List <UnpivotedAssayResult>(); // list of results summarized by target & result type
bool unpivotedTableIsFirst;
object[] vo;
string mtName = null;
int t0 = TimeOfDay.Milliseconds();
mt = eqp.QueryTable.MetaTable;
Dictionary <string, MultiTablePivotBrokerTypeData> mbsi = eqp.Qe.MetaBrokerStateInfo;
if (PivotInCode)
{
mpd = mbsi[MpGroupKey];
if (PivotInCode && mpd.MbInstances.Count == 1 && UnpivotedAssayResult.IsUnpivotedSummarizedMdbAssayTable(mt.Name))
{
PivotInCode = false; // don't multipivot if single unpivoted summary table
}
}
if (!PivotInCode) // if not multipivot then call generic broker
{
base.ExecuteQuery(eqp);
return;
}
if (mpd.FirstTableName != Qt.MetaTable.Name)
{
return; // retrieve data for all tables when we see first table
}
SetupSecondaryMetaBroker(eqp, mpd, out unpivotedTableIsFirst);
mb2 = SecondaryMetaBroker;
mpd.ClearBuffers();
// Retrieve data & store for associated metabrokers
if (mb2 == this)
{
base.ExecuteQuery(eqp); // execute with the base generic broker
}
else
{
mb2.ExecuteQuery(Eqp2); // use the secondary broker that was created
}
AssayDict dict = new AssayDict();
rr = new UnpivotedAssayResult();
int readCnt = 0;
bool includeResultDetail = MdbAssayVoMap.ResultDetailId.Voi >= 0;
while (true)
{
if (mb2 == this)
{
vo = base.NextRow(); // get data via generic broker
}
else
{
vo = mb2.NextRow(); // get data with secondary broker
}
if (vo == null)
{
break;
}
rr.FromValueObject(vo, mb2.MdbAssayVoMap); // parse values into a UnpivotedAssayResult
int rowsFetched = 0, vosCreated = 0;
for (int pup = 0; pup < 2; pup++) // first pass for unpivoted table, 2nd for pivoted by gene
{
//try
//{
if (pup == 0)
{
if (!unpivotedTableIsFirst)
{
continue; // if no unpivoted first table skip this
}
mtName = mpd.FirstTableName; // unpivoted table should be first
}
else // pivoted table
{
if (Lex.IsNullOrEmpty(rr.GeneSymbol))
{
continue; // skip if no target symbol
}
if (Lex.Contains(mpd.FirstTableName, "CORP")) // mapped to pivoted corp only table
{
mtName = MultiDbAssayDataNames.BasePivotTablePrefix + rr.GeneSymbol.ToUpper(); // name of table mapped to
}
else // combined tables
{
mtName = MultiDbAssayDataNames.CombinedPivotTablePrefix + rr.GeneSymbol.ToUpper();
}
}
//}
//catch (Exception ex) { ex = ex; }
mt = MetaTableCollection.Get(mtName);
if (mt == null)
{
continue;
}
if (!mpd.MbInstances.ContainsKey(mt.Name))
{
continue; // have row hash for broker?
}
int mbIdx = 0;
if (mpd.MbInstances[mtName] is MultiDbAssayMetaBroker)
{
mb = (MultiDbAssayMetaBroker)mpd.MbInstances[mtName]; // broker assoc w/table
}
else
{
mbList = (List <MultiDbAssayMetaBroker>)mpd.MbInstances[mtName];
mb = (MultiDbAssayMetaBroker)mbList[0];
}
while (true) // copy out for each metabroker for metatable
{
UnpivotedAssayResultFieldPositionMap voMap = mb.MdbAssayVoMap;
vo = rr.ToValueObject(mb.Qt.SelectedCount, voMap);
if (mb.MultipivotRowList == null)
{
mb.MultipivotRowList = new List <object[]>();
}
mb.MultipivotRowList.Add(vo);
if (mbList == null)
{
break; // single broker
}
mbIdx++; // go to next broker
if (mbIdx >= mbList.Count)
{
break; // at end of brokers?
}
mb = (MultiDbAssayMetaBroker)mbList[mbIdx];
}
} // tables to copy data to loop
} // row fetch loop
return;
}
/// <summary>
/// Prepare query
/// </summary>
/// <param name="parms"></param>
public override string PrepareQuery(
ExecuteQueryParms eqp)
{
List <MultiDbAssayMetaBroker> mbList;
MultiTablePivotBrokerTypeData mpd; // multipivot data for this broker type
Dictionary <string, MultiTablePivotBrokerTypeData> mbsi;
QueryColumn qc;
MetaTable mt;
Eqp = eqp;
Qt = eqp.QueryTable;
mt = eqp.QueryTable.MetaTable;
BuildActivityBinCondFormat();
MdbAssayVoMap = UnpivotedAssayResultFieldPositionMap.NewMdbAssayMap(Qt);
MdbAssayVoMap.InitializeForQueryTable(Qt);
LoadTargetMap();
if ( // check for basic conditions that disallow multipivoting
!eqp.ReturnQNsInFullDetail || // no multipivot if part of calc field
eqp.Qe == null || // need to be able to access queryengine info
//!QueryEngine.AllowMultiTablePivot || // is multipivot even allowed
!UnpivotedAssayResult.IsSummarizedMdbAssayTable(mt.Name)) // summarized tables only
{
return(base.PrepareQuery(eqp));
}
int pivotedColCount = 0;
foreach (QueryColumn qc1 in Qt.QueryColumns)
{ // if any non-key criteria then pivot individually rather than via multipivot
if (qc1.Criteria != "" && !qc1.IsKey)
{
if (UnpivotedAssayResult.IsUnpivotedSummarizedMdbAssayTable(mt.Name) && Qt.Query.SingleStepExecution)
{
} // special case: allow criteria on unpivoted summary table which also apply to associated pivoted tables
else
{
return(base.PrepareQuery(eqp));
}
}
if (IsPivotedColumn(qc1.MetaColumn))
{
pivotedColCount++;
}
}
if (pivotedColCount == 0)
{
return(base.PrepareQuery(eqp)); // must have at least one column to pivot
}
// Store pivot info for queryTable
PivotInCode = true;
Sql = BuildSql(eqp);
if (eqp.Qe.MetaBrokerStateInfo == null)
{
eqp.Qe.MetaBrokerStateInfo = new Dictionary <string, MultiTablePivotBrokerTypeData>();
}
mbsi = eqp.Qe.MetaBrokerStateInfo;
MpGroupKey = MetaBrokerType.TargetAssay.ToString(); // key for broker for query
if (!QueryEngine.AllowMultiTablePivot)
{
MpGroupKey += "_" + Qt.MetaTable.Name;
}
mpd = MultiTablePivotBrokerTypeData.GetMultiPivotData(eqp.Qe.MetaBrokerStateInfo, MpGroupKey, mt.Name);
string geneSymbol = mt.Code;
if (!Lex.IsNullOrEmpty(geneSymbol) && !mpd.TableCodeDict.ContainsKey(geneSymbol))
{
mpd.TableCodeDict[geneSymbol] = new MpdResultTypeData(); // add key to hash list
if (mpd.TableCodeCsvList.Length > 0)
{
mpd.TableCodeCsvList.Append(",");
}
mpd.TableCodeCsvList.Append(Lex.AddSingleQuotes(geneSymbol));
}
mpd.AddMetaBroker(mt.Name, this);
return(Sql);
}
