public static string HelmToSvg(
MoleculeMx mol)
{
string svg = mol.SvgString;
if (mol.PrimaryFormat == MoleculeFormat.Helm && Lex.IsDefined(mol.SvgString))
{
return(svg);
}
string helm = mol.HelmString;
svg = HelmControl.GetSvg(helm);
return(svg);
}
/// <summary>
/// Format Helm-based structure for Html output
/// </summary>
/// <param name="mol"></param>
/// <param name="destRect"></param>
/// <param name="width"></param>
/// <param name="r"></param>
/// <returns></returns>
string FormatBiopolymerStructureHtml(
MoleculeMx mol,
Rectangle destRect,
int width,
int r)
{
string source, molfil, html, shtml, fname, txt, txt2, str, hdisp, rntxt, html_end;
int width2, pixWidth, pixHeight, height, rc, i1;
bool useChimeString = false; // must use molfile format for .Net 4.0 with Draw 4.0
MolCount++;
string objId = "Mol" + MolCount;
//double scaleUp = (SS.I.GraphicsColumnZoom / 100.0) * 1.2; // do graphics scaleup plus a bit
double scaleUp = 1.2; // extra scaleup
pixWidth = (int)(width / 1000.0 * GraphicsMx.LogicalPixelsX * scaleUp);
height = (int)(width * .67);
if (destRect.Height > height)
{
height = destRect.Height;
}
pixHeight = (int)(height / 1000.0 * GraphicsMx.LogicalPixelsY * scaleUp);
string helm = mol.HelmString;
string svg = "";
if (Lex.IsDefined(helm))
{
svg = HelmControl.GetSvg(mol.HelmString);
}
html = "E <td>" + svg + "</td>\t";
Tb.Lines[r] += html; /* finish up & put in buffer */
return(html);
}
/// <summary>
/// Scale and translate structure and format into buffer
/// </summary>
/// <param name="mol">The structure</param>
/// <param name="cellStyle">Style/conditional formatting to apply to cell</param>
/// <param name="commandChar">Command character to use in buffer</param>
/// <param name="x">Coordinate of left side of structure</param>
/// <param name="width">Width of molecule box in milliinches</param>
/// <param name="r">Row in buffer to put on. If less than 0 then return formatted data</param>
/// <param name="heightInLines">number of lines used</param>
public FormattedFieldInfo FormatStructure(
MoleculeMx mol,
CellStyleMx cellStyle,
char commandChar,
int x,
int width,
int r,
ResultsField rfld = null,
DataRowMx dataRow = null)
{
Rectangle destRect, boundingRect;
int height; // formatted height in milliinches
bool markBoundaries;
int fixedHeight;
Bitmap bm;
Font font;
string txt, molfile, molString = "", svg, cid = null;
int translateType, desiredBondLength = 100;
int pixWidth = 0, pixHeight = 0;
bool debug = DataTableManager.DebugDetails;
if (debug)
{
DebugLog.Message("=============================== FormattingStructure ===============================");
}
PerformanceTimer pt = PT.Start("FormatStructure");
Stopwatch swTotal = Stopwatch.StartNew();
Stopwatch sw = Stopwatch.StartNew();
try
{
MoleculeFormat initialCsType = mol.PrimaryFormat;
string initialCsValue = mol.PrimaryValue;
QueryColumn qc = (rfld != null) ? rfld.QueryColumn : null;
FormattedFieldInfo ffi = new FormattedFieldInfo();
if (dataRow != null) // get any cid in row
{
int ki = DataTableManager.DefaultKeyValueVoPos;
if (ki < dataRow.Length)
{
cid = dataRow[ki] as string;
}
}
//DebugLog.Message("FormatStructure " + cid);
//if (!Rf.Grid) x = x; // debug
///////////////////////////////////
// Highlight structure
///////////////////////////////////
if (StructureHighlightPssc != null)
{
ParsedStructureCriteria pssc = StructureHighlightPssc;
// Hilight substructure search match
if (pssc.SearchType == StructureSearchType.Substructure || // regular SSS
pssc.SearchTypeUnion == StructureSearchType.Substructure) // handles related search for just SSS to get hilighting
{
if (HighlightStructureMatches)
{
try
{
mol = StrMatcher.HighlightMatchingSubstructure(mol);
if (DebugMx.False) // debug
{
//string highlightChildren = mol.MolLib.HighlightChildren;
//Color highlightColor = mol.MolLib.HighlightColor;
if (debug)
{
DebugLog.StopwatchMessage("tHilight", sw);
}
}
}
catch (Exception ex) { ex = ex; }
}
if (AlignStructureToQuery)
{
try
{
mol = StrMatcher.AlignToMatchingSubstructure(mol);
if (debug)
{
DebugLog.StopwatchMessage("tOrient", sw);
}
}
catch (Exception ex) { ex = ex; }
}
}
// Hilight SmallWorld structure match
else if (pssc.SearchType == StructureSearchType.SmallWorld) // Hilight SmallWorld structure search results
{
if (SmallWorldDepictions == null)
{
SmallWorldDepictions = new SmallWorldDepictions();
}
SmallWorldPredefinedParameters swp = pssc.SmallWorldParameters;
//DebugLog.Message("Depict " + cid + ", Hilight " + swp.Highlight + ", Align " + swp.Align); // + "\r\n" + new StackTrace(true));
if ((swp.Highlight || swp.Align) & Lex.IsDefined(cid)) // call depiction for these
{
svg = SmallWorldDepictions.GetDepiction(cid, swp.Highlight, swp.Align);
if (Lex.IsDefined(svg)) // have depiction?
{
{
pixWidth = MoleculeMx.MilliinchesToPixels(width);
bm = SvgUtil.GetBitmapFromSvgXml(svg, pixWidth);
ffi.FormattedBitmap = mol.FormattedBitmap = bm; // store in formatting info and chem structure
return(ffi);
}
}
else if (svg == null) // start retrieval of this decpiction type & fall through to get default structure initially
{
SmallWorldDepictions.StartDepictionRetrieval(Qm, StructureHighlightQc, swp.Highlight, swp.Align);
}
else
{
} // tried to get it but failed, fall through to get basic structure
}
}
else if (mol.AltFormDefined("Svg")) // svg form exist (e.g. SmallWorld or "related" structure search)?
{
svg = mol.SvgString;
if (Lex.IsDefined(svg))
{
pixWidth = MoleculeMx.MilliinchesToPixels(width);
bm = SvgUtil.GetBitmapFromSvgXml(svg, pixWidth);
ffi.FormattedBitmap = mol.FormattedBitmap = bm; // store in formatting info and chem structure
return(ffi);
}
}
}
///////////////////////////////////
// Handle each output device
///////////////////////////////////
ffi.HeightInLines = 1; // min of 1 line
if (Rf.SdFile)
{
FormatSdfileStructure(mol);
return(null);
}
int pageHeight = 11000;
if (Rf.PageMargins != null)
{
pageHeight = Rf.PageMargins.Top + Rf.PageHeight + Rf.PageMargins.Bottom;
}
if (Rf.Excel || Rf.Word)
{
translateType = 2;
}
else
{
translateType = 0;
}
if (!Rf.FixedHeightStructures)
{
fixedHeight = 0; // not fixed height
}
else if (Rf.Excel || Rf.Word)
{
fixedHeight = 1; // always fixed height
}
else
{
fixedHeight = 2; // fixed height unless need to expand
}
if (Rf.Word && Rf.FixedHeightStructures)
{
markBoundaries = true;
}
else
{
markBoundaries = false;
}
destRect = new Rectangle(0, 0, width, width * 4 / 5); // default dest rect
///////////////////////////////////////////////////////////////////////////
// Tempory fake generation of HELM & associatedimage for biopolymer testing
///////////////////////////////////////////////////////////////////////////
//if (MoleculeMx.HelmEnabled == DebugMx.False) // artificially generate helm molecules
// MoleculeMx.SetMoleculeToTestHelmString(mol.GetCorpId().ToString(), mol);
///////////////////////////////////////////////////////////////////////////
// End of tempory fake generation of HELM & associatedimage for biopolymer testing
///////////////////////////////////////////////////////////////////////////
bool fitStructure = true;
if (mol.IsChemStructureFormat)
{
if (Rf.Grid) // special scale for grid
{
double scale = (float)width / MoleculeMx.StandardBoxWidth;
desiredBondLength = mol.CdkMol.AdjustBondLengthToValidRange((int)(MoleculeMx.StandardBondLength * scale));
//desiredBondLength = (int)(ChemicalStructure.StandardBondLength * (Rf.PageScale / 100.0));
desiredBondLength = (int)(desiredBondLength * 90.0 / 100.0); // scale down a bit for grid
if (debug)
{
DebugLog.StopwatchMessage("tAdjustBondLength1", sw);
}
}
else // set desired bond length based on page scaling
{
float scale = (float)width / MoleculeMx.StandardBoxWidth;
desiredBondLength = mol.CdkMol.AdjustBondLengthToValidRange((int)(MoleculeMx.StandardBondLength * scale));
//desiredBondLength = (int)(ChemicalStructure.StandardBondLength * (Rf.PageScale / 100.0));
if (debug)
{
DebugLog.StopwatchMessage("tAdjustBondLength2", sw);
}
}
if (desiredBondLength < 1)
{
desiredBondLength = 1;
}
if (debug)
{
DebugLog.StopwatchMessage("tBeforeFit", sw);
}
if (fitStructure)
{
mol.CdkMol.FitStructureIntoRectangle // scale and translate structure into supplied rectangle.
(ref destRect, desiredBondLength, translateType, fixedHeight, markBoundaries, pageHeight, out boundingRect);
}
if (debug)
{
DebugLog.StopwatchMessage("tFitStructure", sw);
}
ffi.HeightInLines = (int)(destRect.Height / Rf.LineHeight + 1); // lines needed
}
else if (mol.IsBiopolymerFormat)
{
if (mol.PrimaryFormat == MoleculeFormat.Helm && Rf.Excel)
{
svg = HelmControl.GetSvg(mol.HelmString);
float inchWidth = width / 1000.0f; // convert width milliinches to inches
Svg.SvgDocument svgDoc = SvgUtil.AdjustSvgDocumentToFitContent(svg, inchWidth, Svg.SvgUnitType.Inch);
RectangleF svgbb = svgDoc.Bounds;
float ar = svgbb.Width / svgbb.Height; // aspect ratio of svg bounding box
height = (int)(width / ar); // height in milliinches
ffi.HeightInLines = (int)(height / Rf.LineHeight) + 1; // lines needed
destRect = new Rectangle(0, 0, width, height);
}
}
//////////////////////////
/// Output to Grid
//////////////////////////
if (Rf.Grid)
{
pixWidth = MoleculeMx.MilliinchesToPixels(destRect.Width);
pixHeight = MoleculeMx.MilliinchesToPixels(destRect.Height);
if (cellStyle == null)
{
if (Qm == null || Qm.MoleculeGrid == null)
{
font = new Font("Tahoma", 8.25f);
}
else
{
font = new Font(Qm.MoleculeGrid.Font, FontStyle.Underline);
}
cellStyle = new CellStyleMx(font, Color.Blue, Color.Empty);
}
if (mol.IsChemStructureFormat) // molfile type molecule
{
if (debug)
{
DebugLog.StopwatchMessage("tBeforeGetDisplayPreferences", sw);
}
DisplayPreferences dp = mol.GetDisplayPreferences();
if (debug)
{
DebugLog.StopwatchMessage("tGetDisplayPreferences", sw);
}
//desiredBondLength = mol.CdkMol.AdjustBondLengthToValidRange(desiredBondLength); // be sure bond len within allowed range
//if (debug) DebugLog.StopwatchMessage("tAdjustBondLengthToValidRange", sw);
//dp.StandardBondLength = MoleculeMx.MilliinchesToDecipoints(desiredBondLength);
bm = mol.CdkMol.GetFixedHeightMoleculeBitmap(pixWidth, pixHeight, dp, cellStyle, mol.Caption);
if (debug)
{
DebugLog.StopwatchMessage("tGetBitmap", sw);
}
}
else if (mol.IsBiopolymerFormat) // Output HELM image for biopolymer
{
pixWidth = MoleculeMx.MilliinchesToPixels(width);
bm = HelmConverter.HelmToBitmap(mol, pixWidth);
}
else
{
bm = new Bitmap(1, 1);
}
ffi.FormattedBitmap = mol.FormattedBitmap = bm; // store in formatting & structure
ffi.FormattedText = "Formatted"; // indicate formatted (could save structure string but not needed and avoids possible conversion overhead)
return(ffi);
}
//////////////////////////
/// Output to Html
//////////////////////////
else if (Rf.Html)
{
if (r >= 0)
{
AssureTbFree(0, r + ffi.HeightInLines - 1);
}
if (mol.IsChemStructureFormat)
{
FormatChemStructureHtml(mol, destRect, width, r);
}
else if (mol.IsBiopolymerFormat)
{
FormatBiopolymerStructureHtml(mol, destRect, width, r);
}
if (debug)
{
DebugLog.StopwatchMessage("tFormatHtmlStructure", sw);
}
ffi.FormattedBitmap = mol.FormattedBitmap;
ffi.FormattedText = mol.FormattedText;
return(ffi);
}
/////////////////////////////////////////////////////////////////
/// Other format, store Smiles or Helm & any cellStyle in buffer
/////////////////////////////////////////////////////////////////
else
{
if (mol.IsChemStructureFormat)
{
if (Rf.ExportStructureFormat == ExportStructureFormat.Smiles)
{
molString = mol.GetSmilesString();
}
else
{
molString = mol.GetChimeString(); // use Chime if not smiles
}
}
else if (mol.IsBiopolymerFormat)
{
molString = mol.PrimaryValue; // usually Helm but could be sequence
}
txt = String.Format("{0} {1} {2} {3} {4} {5} {6}",
x, width, destRect.Left, destRect.Top, destRect.Right, destRect.Bottom, molString);
if (cellStyle != null) // apply style to cell?
{
txt += " <CellStyle " + cellStyle.Serialize() + ">";
}
txt = commandChar + " " + txt + "\t";
if (r >= 0)
{
AssureTbFree(0, r + ffi.HeightInLines - 1);
Tb.Lines[r] += txt; // put in buffer
}
else
{
return(new FormattedFieldInfo(txt)); // just return formatting
}
}
return(null);
}
catch (Exception ex)
{
DebugLog.Message(DebugLog.FormatExceptionMessage(ex));
return(null);
}
finally
{
pt.Update();
int formatCount = pt.Count;
//ClientLog.Message(pt.ToString() + ", " + cs.GetMolHeader()[2]); // + ", " + new StackTrace(true));
if (debug)
{
DebugLog.StopwatchMessage("tTotalTime", swTotal);
}
}
}
/// <summary>
/// Sync the Mobius CorpMoltable replicate used to retrieve Smiles
/// Syntax: UpdateCorpDbMoltableMx [ ByDateRange | ByCorpIdRange | LoadMissing | <singleCorpId>]
/// </summary>
/// <returns></returns>
public static string UpdateCorpDbMoltableMx(
string args)
{
DateTime moleculeDateTime = DateTime.MinValue;
double mw;
string msg = "", sql = "", maxCorpIdSql, mf = "", chime = "", smiles = "", checkPointDate = "", helm = "", sequence = "", svg = "";
object[][] pva = null;
int pvaCount = 0, CorpId, lowCorpId = 0, highCorpId = 0, srcMaxCorpId = 0;
int SelectChunkSize = 20; // small chunks
int InsertBufferSize = 10;
//int SelectChunkSize = 100000; // big chunks
//int InsertBufferSize = 1000;
// Select data from corp_moltable by CorpId range
const string SelectByCorpIdRange = @"
SELECT
m.corp_nbr,
chime(m.ctab),
m.molformula,
m.molweight,
null molsmiles,
s.helm_txt,
s.sequence_txt,
m.molecule_date
FROM
corp_owner.corp_moltable m,
corp_owner.corp_substance s
where
m.corp_nbr > 0
and s.corp_nbr = m.corp_nbr
and (s.status_code is null or s.status_code = 'A')
ORDER BY corp_nbr";
// Select data from corp_moltable by date range comparing to corp_moltable_mx
const string SelectByDateRange = @"
select
m.corp_nbr,
chime(m.ctab),
m.molformula,
m.molweight,
null molsmiles,
s.helm_txt,
s.sequence_txt,
m.molecule_date,
m2.molecule_date
from
corp_owner.corp_moltable m,
corp_owner.corp_substance s,
corp_moltable_mx m2
where
m.molecule_date > to_date('1-jan-1900 000000','DD-MON-YYYY HH24MISS')
and s.corp_nbr = M.CORP_NBR
and (s.status_code is null or s.status_code = 'A')
and m2.corp_nbr (+) = m.corp_nbr
and m2.molecule_date (+) != m.molecule_date
order by m.molecule_date" ;
// Select for missing smiles strings, ex: Update CorpDbMoltableMx LoadMissing mx.molecule_date > '1-jan-2014'
const string SelectMissingSmilesFix = @"
select /* check for CorpIds in corp_moltable not in corp_moltable_mx */
corp_nbr,
chime(ctab),
molformula,
molweight,
null molsmiles,
helm_txt,
sequence_txt,
molecule_date
from
(
select
m.*,
s.helm_txt,
s.sequence_txt,
mx.molsmiles molsmiles_mx
from
corp_owner.corp_moltable m,
corp_owner.corp_substance s,
corp_moltable_mx mx
where
s.corp_nbr = M.CORP_NBR
and (s.status_code is null or s.status_code = 'A')
and mx.corp_nbr (+) = m.corp_nbr
and 1=1 /* condition to substitute */
) m
where molsmiles_mx is null /* extra condition */
order by corp_nbr" ;
// Insert missing helm info
const string SelectMissingHelmFix = @"
select /* check for CorpIds in corp_moltable not in corp_moltable_mx */
corp_nbr,
chime(ctab),
molformula,
molweight,
null molsmiles,
helm_txt,
sequence_txt,
molecule_date
from
(
select
m.*,
s.helm_txt,
s.sequence_txt,
mx.molsmiles molsmiles_mx
from
corp_owner.corp_moltable m,
corp_owner.corp_substance s,
corp_moltable_mx mx
where
s.corp_nbr = M.CORP_NBR
and (s.status_code is null or s.status_code = 'A')
and mx.corp_nbr (+) = m.corp_nbr
and 1=1 /* condition to substitute */
) m
where length(helm_txt) > 0 /* extra condition */
order by corp_nbr" ;
// Secondary "large" structure table (~5k mols)
const string SelectLargeMols = @"
select
corp_nbr,
to_clob(molstructure),
to_clob(molformula),
molweight,
molsmiles,
null helm_txt,
null sequence_txt,
molecule_date
from
(select
corp_srl_nbr corp_nbr,
'CompoundId=' || corp_srl_nbr molstructure,
null ctab,
mlclr_frml_txt molformula,
mlclr_wgt molweight,
null molsmiles,
null molecule_date
from rdm_owner.rdm_sbstnc
where rdw_src_cd = 'LRG'" ;
// Insert statement
const string InsertSql = @"
insert into mbs_owner.corp_moltable_mx (
corp_nbr,
molstructure,
molformula,
molweight,
molsmiles,
molecule_date)
values (:0, :1, :2, :3, :4, :5)" ;
// Build select sql
bool byDateRange = false, byCorpIdRange = false, missingFix = true, deleteExisting = true;
string missingFixCriteria = "";
if (Lex.IsUndefined(args) || Lex.Eq(args, "ByDateRange"))
{
byDateRange = true;
}
else if (Lex.Eq(args, "ByCorpIdRange"))
{
byCorpIdRange = true;
Progress.Show("Getting range of CorpIds to insert...");
maxCorpIdSql = "select max(corp_nbr) from corp_owner.corp_moltable"; // get highest CorpId in source db
srcMaxCorpId = SelectSingleValueDao.SelectInt(maxCorpIdSql);
if (srcMaxCorpId < 0)
{
srcMaxCorpId = 0;
}
maxCorpIdSql = "select max(corp_nbr) from mbs_owner.corp_moltable_mx"; // get highest CorpId in dest db
highCorpId = SelectSingleValueDao.SelectInt(maxCorpIdSql);
if (highCorpId < 0)
{
highCorpId = 0;
}
}
else if (Lex.StartsWith(args, "LoadMissing"))
{
missingFix = true;
if (args.Contains(" "))
{
missingFixCriteria = args.Substring(10).Trim();
}
}
else if (int.TryParse(args, out srcMaxCorpId)) // single CorpId
{
byCorpIdRange = true;
highCorpId = srcMaxCorpId - 1; // say 1 less is the max we have
}
else
{
return("Syntax: UpdateCorpDbMoltableMx [ ByDateRange | ByCorpIdRange | LoadMissing | <singleCorpId>]");
}
Log("UpdateCorpDbMoltableMx started: " + args);
int readCount = 0, insCount = 0, insertCount = 0, updateCount = 0, undefinedStructures = 0, smilesSuccess = 0, smilesFails = 0, helmStructures = 0;
List <string> CorpIdList = new List <string>();
for (int chunk = 1; ; chunk++) // loop over chunks
{
if (byDateRange) // single chunk
{
if (chunk > 1)
{
break; // break 2nd time through
}
checkPointDate = UserObjectDao.GetUserParameter("MOBIUS", "UpdateCorpDbMoltableMxCheckpointDate", "01-sep-2013 000000");
//UserObjectDao.SetUserParameter("MOBIUS", "UpdateCorpDbMoltableMxCheckpointDate", checkPointDate);
sql = Lex.Replace(SelectByDateRange, "1-jan-1900 000000", checkPointDate);
msg = "Reading where date >= " + checkPointDate;
}
else if (byCorpIdRange) // by CorpId range
{
if (highCorpId >= srcMaxCorpId)
{
break; // done
}
lowCorpId = highCorpId + 1; // start of next chunk
highCorpId = lowCorpId + SelectChunkSize;
if (highCorpId >= srcMaxCorpId)
{
highCorpId = srcMaxCorpId;
}
sql = Lex.Replace(SelectByCorpIdRange, "corp_nbr > 0", "corp_nbr between " + lowCorpId + " and " + highCorpId);
msg = "Reading: " + lowCorpId + " to " + highCorpId + ", Reads: " + readCount + ", Inserts: " + insertCount;
}
else if (missingFix)
{
if (chunk > 1)
{
break; // break 2nd time through
}
sql = SelectMissingHelmFix;
if (Lex.IsDefined(missingFixCriteria)) // substitute any criteria
{
sql = Lex.Replace(sql, "1=1", missingFixCriteria);
}
msg = "Fixing missing data";
}
Progress.Show(msg);
DbCommandMx readCmd = new DbCommandMx();
readCmd.MxConn = DbConnectionMx.GetConnection("prd123");
readCmd.PrepareUsingDefinedConnection(sql, null);
DbDataReader rdr = readCmd.ExecuteReader();
DbCommandMx insertCmd = new DbCommandMx();
OracleDbType[] pta = new OracleDbType[6];
pta[0] = OracleDbType.Int32; // corp_nbr
pta[1] = OracleDbType.Clob; // molstructure
pta[2] = OracleDbType.Clob; // molformula
pta[3] = OracleDbType.Double; // molweight
pta[4] = OracleDbType.Clob; // smiles
pta[5] = OracleDbType.Date; // molecule_date
insertCmd.Prepare(InsertSql, pta);
insertCmd.BeginTransaction(); // be sure we have a transaction going
pva = DbCommandMx.NewObjectArrayArray(6, InsertBufferSize); // alloc insert row array
object[] vo = new object[6];
while (true)
{
bool readOk = rdr.Read();
if (readOk)
{
rdr.GetValues(vo);
CorpId = readCmd.GetInt(0); // corp_nbr
vo[0] = CorpId;
CorpIdList.Add(CorpId.ToString());
if (!readCmd.IsNull(1)) // molstructure
{
chime = readCmd.GetClob(1);
chime = OracleMx.ClearStringIfExceedsMaxStringSize(chime);
vo[1] = chime;
}
else
{
chime = "";
}
if (!readCmd.IsNull(2)) // molformula
{
mf = readCmd.GetClob(2);
mf = OracleMx.ClearStringIfExceedsMaxStringSize(mf);
vo[2] = mf;
}
if (!readCmd.IsNull(3)) // molweight
{
mw = readCmd.GetDouble(3);
vo[3] = mw;
}
if (Lex.IsDefined(chime)) // molsmiles - calculate from chime string
{
MoleculeMx cs = new MoleculeMx(MoleculeFormat.Chime, chime);
if (cs.AtomCount > 1) // need more than one atom
{
MoleculeMx cs2 = cs.ConvertTo(MoleculeFormat.Smiles);
smiles = cs2.GetSmilesString();
if (Lex.IsDefined(smiles))
{
smilesSuccess++;
}
else
{
Log("Smiles conversion failure for CorpId: " + CorpId);
smilesFails++;
}
smiles = OracleMx.ClearStringIfExceedsMaxStringSize(smiles);
vo[4] = smiles;
}
else
{
undefinedStructures++;
}
}
else
{
undefinedStructures++;
}
if (!readCmd.IsNull(5))
{
helm = readCmd.GetClob(5);
if (Lex.IsDefined(helm))
{
svg = HelmControl.GetSvg(helm);
vo[1] = SvgUtil.CompressSvgString(svg); // store compressed svg in molstructure column for now
helmStructures++;
}
}
if (!readCmd.IsNull(6))
{
sequence = readCmd.GetClob(6);
if (Lex.IsDefined(sequence))
{
// nothing yet
}
}
moleculeDateTime = DateTime.MinValue;
if (!readCmd.IsNull(7)) // molecule_date
{
moleculeDateTime = readCmd.GetDateTime(7);
vo[5] = moleculeDateTime;
}
for (int pi = 0; pi < 6; pi++) // invert for insert
{
pva[pi][pvaCount] = vo[pi];
}
if (Debug)
{
msg = String.Format("CorpId: {0}, mf: {1}, chime: {2}, smiles: {3}", CorpId.ToString(), mf.Length, chime.Length, smiles.Length);
Log(msg);
}
pvaCount++;
}
if (pvaCount >= InsertBufferSize || (!readOk && pvaCount > 0)) // write if buffer full or at end
{
try
{
if (deleteExisting)
{
int delCount = DoDeletes(CorpIdList);
updateCount += delCount; // count deletes as updates
insertCount -= delCount; // subtract from inserts
}
CorpIdList.Clear();
insCount = insertCmd.ExecuteArrayNonReader(pva, ref pvaCount);
insertCmd.Commit();
insertCmd.BeginTransaction();
insertCount += insCount;
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
if (byDateRange)
{
string checkPointDate2 = String.Format("{0:dd-MMM-yyyy HHmmss}", moleculeDateTime); // format date time that will work with oracle
UserObjectDao.SetUserParameter("MOBIUS", "UpdateCorpDbMoltableMxCheckpointDate", checkPointDate2);
msg = "Processing where date >= " + checkPointDate + ", Reads: " + readCount + ", Inserts: " + insertCount + ", Updates: " + updateCount;
}
else if (byCorpIdRange) // CorpId range
{
msg = "Processing: " + lowCorpId + " to " + highCorpId + ", Reads: " + readCount + ", Inserts: " + insertCount;
}
else if (missingFix)
{
msg = "Fixing missing smiles, Updates: " + updateCount;
}
msg += String.Format(", Undefined structures: {0} , Smiles failures: {1}, Helms: {2}", undefinedStructures, smilesFails, helmStructures);
Progress.Show(msg);
}
if (!readOk)
{
break;
}
readCount++;
}
readCmd.Dispose();
insertCmd.Dispose();
} // end for select chunk
msg = "UpdateCorpDbMoltableMx - Inserts: " + insertCount + ", Updates: " + updateCount;
msg += String.Format(", Undefined structures: {0} , Smiles failures: {1}, Helms: {2}", undefinedStructures, smilesFails, helmStructures);
Log(msg);
return(msg);
}