/// <summary>
/// Get value object for row & col
/// </summary>
/// <param name="ri"></param>
/// <param name="qc"></param>
/// <param name="voi"></param>
/// <param name="returnFilteredValuesAsNulls"></param>
/// <param name="returnUnmarkedValuesAsNulls"></param>
/// <param name="dr"></param>
/// <returns></returns>
internal object GetVo(
int ri,
QueryColumn qc,
int voi,
bool returnFilteredValuesAsNulls,
bool returnUnmarkedValuesAsNulls,
out DataRowMx dr)
{
object o;
dr = Dt.Rows[ri];
DataRowAttributes dra = Dtm.GetRowAttributes(dr);
if (returnFilteredValuesAsNulls && dra.Filtered) // store filtered values as nulls that don't get shown
{
o = DBNull.Value;
}
else if (Dtm.RowSubset != null && !Dtm.RowSubset.ContainsKey(ri)) // if subsetting rows & not included return as null
{
o = DBNull.Value;
}
else if (returnUnmarkedValuesAsNulls && !Dtm.RowIsMarked(dr)) // also null if not marked
{
o = DBNull.Value;
}
else
{
//if (Query.Tables.Count > 1 && qc.MetaColumn.MetaTable.IsRootTable) // get from root table row if appropriate
// dr = Dt.Rows[dra.FirstRowForKey];
int ti = qc.QueryTable.TableIndex; // get table corresponding to specified column
int dri2 = Dtm.AdjustDataRowToCurrentDataForTable(ri, ti, true); // get the actual row for this table associated with this base row
//if (dri2 != ri) dri2 = dri2; // debug
if (dri2 >= 0)
{
dr = Qm.DataTable.Rows[dri2];
o = dr[voi];
}
else
{
o = DBNull.Value;
}
}
return(o);
}
/// <summary>
/// Summarize pivoted data
/// </summary>
/// <param name="sumLevel"></param>
/// <param name="sumMethod"></param>
/// <returns></returns>
public QueryManager SummarizePivoted(
TargetAssaySummarizationLevel sumLevel,
SummarizationType sumMethod,
ColumnsToTransform colsToSumm,
OutputDest outputDest,
TargetMap targetMap)
{
QueryManager qm2;
QueryTable qt;
DataRow dr, dr2;
DataRowAttributes dra;
string cid = "", currentCid;
int rti, rfi;
qm2 = InitializeSubqueryQm(MultiDbAssayDataNames.CombinedNonSumTableName);
#if false
// Get the data for a compound, summarize & add results to data for charting
DataTableManager dtm = Qm0.DataTableManager;
for (int dri = 0; dri < dtm.DataTable.Rows.Count; dri++)
{
DataRow dr = dtm.DataTable.Rows[dri];
DataRowAttributes dra = GetRowAttributes(dr);
string keyVal = dr[KeyValueVoPos] as string;
if (keyVal != curKeyVal || Rf.Tables.Count <= 1) // going to new key
{
curKeyVal = keyVal;
curKeyRow = dri;
rowsForKey = 0;
}
rowsForKey++;
object o = dr[dci];
// if (o is string && ((string)o) == "") o = o; // debug
if (NullValue.IsNull(o))
{
if (rowsForKey == 0 || // count as null if first row for key
dra.TableRowState[colInfo.TableIndex] != RowStateEnum.Undefined) // or real row data but col is null
{
stats.NullsExist = true;
}
continue;
}
else if (o is MobiusDataType)
{ // create a MobiusDataType that we can point to
o = MobiusDataType.New(o);
dr[dci] = o;
}
MobiusDataType val = o as MobiusDataType;
try
{
if (val.FormattedText == null) // get formatted text if not done yet
{
val = QueryManager.ResultsFormatter.FormatField(rt, ti, rfld, fi, dr, dri, val, -1, false);
}
dictKey = val.FormattedText.ToUpper();
if (!stats.DistinctValueDict.ContainsKey(dictKey))
{
DistinctValueAndPosition dvp = new DistinctValueAndPosition();
dvp.Value = val;
stats.DistinctValueDict[dictKey] = dvp;
}
}
catch (Exception ex) { val = val; }
} // row loop
dtm.n
#endif
return(qm2);
}
/// <summary>
/// Write out rows from table if caching has been activated
/// </summary>
internal void WriteRowsToCache(bool keepLastKeyValue)
{
DataRowMx dr;
string firstKey = "", lastKey = "";
int rowsRemovedInThisCall = 0, ri, ri2, srpi;
if (!AllowCaching)
{
return;
}
if (CacheStartPosition < 0 || CacheWriter == null)
{
return; // just return if caching not active
}
if (DataTableMx.Rows.Count < CacheMiminumRowsRequiredForWriting)
{
return;
}
lock (DataTransferLock) // lock the DataTable while changing
{
if (DataTableFetchPosition < CacheStartPosition)
{
return; // only cache if fetching beyond start position
}
if (DataTableFetchPosition < DataTableMx.Rows.Count - 1)
{
return; // can only cache out if at end of available rows
}
dr = DataTableMx.Rows[CacheStartPosition];
firstKey = dr[KeyValueVoPos] as string;
ri = DataTableMx.Rows.Count - 1;
dr = DataTableMx.Rows[ri];
lastKey = dr[KeyValueVoPos] as string; // key we want to keep
if (QueryManager.MoleculeGrid != null)
{
QueryManager.MoleculeGrid.BeginUpdate();
}
ri = CacheStartPosition; // start deleting here
while (ri < DataTableMx.Rows.Count)
{ // delete anything with key other than end value
dr = DataTableMx.Rows[ri];
string key2 = dr[KeyValueVoPos] as string; // end key with possibly partial data that we want to keep
if (keepLastKeyValue && key2 == lastKey)
{
break;
}
bool doCacheIO = !PurgeDataTableWithoutWritingToCacheFile;
if (doCacheIO)
{
object[] oa = dr.ItemArray;
StringBuilder sb = VoArray.SerializeToText(oa, KeyValueVoPos, oa.Length - KeyValueVoPos);
string lenStr = String.Format("{0,8:00000000}", sb.Length);
CacheWriter.Write(lenStr); // write length
CacheWriter.Write(sb); // write record
RowsWrittenToCache++;
}
DataTableMx.Rows.Remove(dr);
RowsRemovedFromDataTable++;
rowsRemovedInThisCall++;
}
DataTableFetchPosition -= rowsRemovedInThisCall; // adjust fetch position
for (ri2 = CacheStartPosition; ri2 < DataTableMx.Rows.Count; ri2++)
{ // adjust row indexes held the row attributes in rows below those paged out
DataRowAttributes dra = GetRowAttributes(ri2);
if (dra == null)
{
continue;
}
dra.FirstRowForKey -= rowsRemovedInThisCall;
if (dra.SubRowPos == null)
{
continue;
}
for (srpi = 0; srpi < dra.SubRowPos.Length; srpi++)
{
dra.SubRowPos[srpi] -= rowsRemovedInThisCall;
}
}
} // end of locked section
if (QueryManager.MoleculeGrid != null)
{
QueryManager.MoleculeGrid.EndUpdate();
QueryManager.MoleculeGrid.Refresh();
Application.DoEvents();
}
if (DebugCaching)
{
ClientLog.Message(
"CachedRows - DataTable.Rows.Count: " + DataTableMx.Rows.Count +
", FirstKey: " + firstKey + ", LastKey: " + lastKey +
", RowsRemovedFromDataTable (This Call): " + rowsRemovedInThisCall +
", RowsRemovedFromDataTable (Total): " + RowsRemovedFromDataTable +
", RowsWrittenToCache (Total): " + RowsWrittenToCache +
", DataTableFetchPosition: " + DataTableFetchPosition);
}
return;
}
