/// <summary>
/// Select basic project info with criteria
/// </summary>
/// <param name="criteria"></param>
/// <returns></returns>
public static List <AfsProject> SelectWithCriteria(string criteria)
{
MetaTreeNode mtn;
string sql = @"
select
proj_id,
mbs_project_code,
proj_name,
mbs_dht_folder_code,
dht_folder_name,
platform_name
from
<mbs_owner>.afs_project p
where
afs_current = 1
and mbs_project_code is not null
and <criteria>
order by upper(dht_folder_name), upper(proj_name)
" ;
sql = Lex.Replace(sql, "<mbs_owner>", AfsProject.AfsTableSchema);
sql = Lex.Replace(sql, "<criteria>", criteria);
List <AfsProject> projects = new List <AfsProject>();
DbCommandMx dao = new DbCommandMx();
dao.Prepare(sql);
dao.ExecuteReader();
while (dao.Read())
{
AfsProject p = new AfsProject();
p.ProjId = dao.GetInt(0);
p.MbsProjectName = dao.GetString(1).ToUpper();
p.ProjectLabel = dao.GetString(2);
if (Lex.IsNullOrEmpty(p.ProjectLabel))
{
p.ProjectLabel = p.MbsProjectName;
}
p.MbsDhtFolderName = dao.GetString(3).ToUpper();
p.DhtFolderLabel = dao.GetString(4).ToUpper();
if (Lex.IsNullOrEmpty(p.DhtFolderLabel))
{
p.DhtFolderLabel = p.MbsDhtFolderName;
}
p.PlatformName = dao.GetString(5).ToUpper();
projects.Add(p);
}
dao.CloseReader();
return(projects);
}
/// <summary>
/// Get dictionary of result types
/// </summary>
/// <returns></returns>
public static Dictionary <int, AssayDbResultType> GetResultTypeDict()
{
if (ResultTypeDict != null)
{
return(ResultTypeDict);
}
string sql = @"
select
rt.assay_rslt_typ_id,
rt.blgcl_rslt_typ_shrt_nm,
rt.sum_md_txt,
l.rslt_lvl_nm
from
metadata_owner.rslt_typ rt,
metadata_owner.rslt_lvl l
where
l.rslt_lvl_id = rt.rslt_lvl_id
and rt.sts_id = 1
and l.sts_id = 1";
Dictionary <int, AssayDbResultType> dict = new Dictionary <int, AssayDbResultType>();
ResultTypeDict = dict;
DbCommandMx drd = new DbCommandMx();
drd.Prepare(sql);
drd.ExecuteReader();
while (true)
{
if (!drd.Read())
{
break;
}
AssayDbResultType rt = new AssayDbResultType();
rt.RsltTypeId = drd.GetInt(0);
rt.Name = drd.GetString(1);
rt.SumMdTxt = drd.GetString(2);
rt.RsltLvl = drd.GetString(3);
dict[rt.RsltTypeId] = rt;
}
drd.CloseReader();
return(dict);
}
/// <summary>
///
/// </summary>
/// <param name="criteria"></param>
/// <returns></returns>
public static List <AfsAssay> SelectWithCriteria(string criteria)
{
MetaTreeNode mtn;
string sql = @"
select
p.proj_id,
p.mbs_project_code,
proj_name,
p.mbs_dht_folder_code,
dht_folder_name,
platform_name,
assay_id,
assay_name,
assay_db,
assay_use
from
<mbs_owner>.afs_project p,
<mbs_owner>.afs_assay a
where
p.afs_current = 1
and p.mbs_project_code is not null
and a.afs_current = 1
and a.proj_id = p.proj_id
and <criteria>
order by upper(dht_folder_name), upper(proj_name), upper(assay_name)
" ;
sql = Lex.Replace(sql, "<mbs_owner>", AfsProject.AfsTableSchema);
sql = Lex.Replace(sql, "<criteria>", criteria);
List <AfsAssay> assays = new List <AfsAssay>();
DbCommandMx dao = new DbCommandMx();
dao.Prepare(sql);
dao.ExecuteReader();
while (dao.Read())
{
AfsAssay a = new AfsAssay();
a.ProjId = dao.GetInt(0);
a.MbsProjectName = dao.GetString(1).ToUpper();
a.ProjectLabel = dao.GetString(2);
a.MbsDhtFolderName = dao.GetString(3).ToUpper();
a.DhtFolderLabel = dao.GetString(4).ToUpper();
a.Platform = dao.GetString(5).ToUpper();
a.AssayId = dao.GetInt(6);
a.AssayLabel = dao.GetString(7);
a.AssayDb = dao.GetString(8).ToUpper();
a.AssayUse = dao.GetString(9).ToUpper();
assays.Add(a);
}
dao.CloseReader();
return(assays);
}
/// <summary>
/// Select an Oracle Blob value
/// </summary>
/// <param name="table"></param>
/// <param name="matchCol"></param>
/// <param name="typeCol"></param>
/// <param name="contentCol"></param>
/// <param name="matchVal"></param>
public static void SelectOracleBlob(
string table,
string matchCol,
string typeCol,
string contentCol,
string matchVal,
out string typeVal,
out byte[] ba)
{
typeVal = null;
ba = null;
string sql =
"select " + typeCol + ", " + contentCol + " " +
"from " + table + " " +
"where " + matchCol + " = :0";
DbCommandMx drd = new DbCommandMx();
drd.PrepareMultipleParameter(sql, 1);
for (int step = 1; step <= 2; step++) // try two different forms of matchVal
{
if (step == 2) // try alternate form of spaces
{
if (matchVal.Contains("%20"))
{
matchVal = matchVal.Replace("%20", " "); // convert html spaces to regular spaces
}
else
{
matchVal = matchVal.Replace(" ", "%20"); // convert regular spaces to html spaces
}
}
drd.ExecuteReader(matchVal);
if (!drd.Read())
{
continue;
}
typeVal = drd.GetString(0);
if (drd.Rdr.IsDBNull(1))
{
break;
}
OracleBlob ob = drd.OracleRdr.GetOracleBlob(1);
if (ob != null && ob.Length >= 0)
{
ba = new byte[ob.Length];
ob.Read(ba, 0, (int)ob.Length);
}
break; // have value
}
drd.Dispose();
return;
}
/// <summary>
/// Read the list of compounds for a library
/// </summary>
/// <param name="libId"></param>
/// <returns></returns>
public static CidList ReadLibrary(
int libId)
{
CidList l = new CidList();
DbCommandMx dao = new DbCommandMx();
string sql = @"
SELECT l.library_name, l.library_desc_text, s.corp_nbr
FROM corp_owner.corp_substance s,
corp_owner.corp_library_substance ls,
corp_owner.corp_library l
WHERE
l.lib_id = <libId> and
s.cpd_id = ls.cpd_id and
l.lib_id = ls.lib_id" ;
sql = Lex.Replace(sql, "<libId>", libId.ToString());
dao.Prepare(sql);
dao.ExecuteReader();
MetaTable rootMt = MetaTableCollection.Get(MetaTable.PrimaryRootTable);
while (dao.Read())
{
if (Lex.IsNullOrEmpty(l.UserObject.Name))
{
string name = dao.GetString(0);
if (Lex.IsNullOrEmpty(name) || Lex.IsInteger(name))
{
name = dao.GetString(1); // use desc if no name or just a number
}
if (Lex.IsNullOrEmpty(name))
{
name = "Library " + libId;
}
l.UserObject.Name = name;
}
int intCorpId = dao.GetInt(2);
string corpId = CompoundId.Normalize(intCorpId, rootMt);
l.Add(corpId);
}
dao.CloseReader();
dao.Dispose();
return(l);
}
/// <summary>
/// Get list of CIDS that are in the oracle database but not the Mobius fingerprint files
/// </summary>
/// <returns></returns>
static List <string> GetMissingCidList()
{
string sql = "", cid;
int readCnt = 0;
HashSet <string> knownCidsSet = FpDao.GetExistingCidSet(); // get list of cids in DB
ExistingUndefinedStructureCids = FpDao.ReadUndefinedStructuresCids(); // cids that have undefined structures and aren't in DB
knownCidsSet.UnionWith(ExistingUndefinedStructureCids);
List <string> cidList = new List <string>();
if (CorpDatabase)
{
sql = SelectAllCorpIds;
//sql = Lex.Replace(sql, "s.corp_nbr = m.corp_nbr", "s.corp_nbr = m.corp_nbr and s.corp_nbr = 3431641"); // debug
//sql = Lex.Replace(sql, "s.corp_nbr = m.corp_nbr", "s.corp_nbr = m.corp_nbr and s.corp_nbr between 1000000 and 1100000"); // debug
}
else // chembl
{
sql = SelectAllChemblIds;
}
DbCommandMx rdr = DbCommandMx.PrepareAndExecuteReader(sql);
while (rdr.Read())
{
readCnt++;
if (CorpDatabase)
{
int corpId = rdr.GetInt(0); // corp_nbr
cid = corpId.ToString();
cid = CompoundId.NormalizeForDatabase(cid);
}
else
{
cid = rdr.GetString(0); // chembl
}
if (!knownCidsSet.Contains(cid))
{
cidList.Add(cid);
}
}
rdr.CloseReader();
return(cidList);
}
/// <summary>
/// ReadSqlStatement
/// </summary>
/// <param name="name"></param>
/// <param name="id"></param>
/// <param name="sqlStmt"></param>
/// <param name="owner"></param>
/// <returns></returns>
public static bool ReadSqlStatement(
string name,
int version,
out string sqlStmt,
out string keyColName,
out string owner)
{
string sql = @"
select
sql,
key_col_name,
ownr_id
from dev_mbs_owner.mbs_spotfire_sql
where name = '" + name + "' and " +
"version = " + version;
DbCommandMx cmd = new DbCommandMx();
cmd.Prepare(sql);
cmd.ExecuteReader();
sqlStmt = keyColName = owner = null;
bool exists = cmd.Read();
if (exists)
{
sqlStmt = cmd.GetClob(0);
keyColName = cmd.GetString(1);
owner = cmd.GetString(2);
}
cmd.CloseReader();
cmd.Dispose();
return(exists);
}
/// <summary>
/// Retrieve theoretical elemental composition value from Cassper database
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public object GetElementalAnalysisPct(
string cassperId,
string aSymbol)
{
DbCommandMx drd = new DbCommandMx();
string sql =
"select comp_pct " +
"from cas_owner.cas_structure " +
"where cassper_id = :0";
drd.PrepareMultipleParameter(sql, 1);
drd.ExecuteReader(cassperId);
if (!drd.Read() || drd.IsNull(0))
{
drd.Dispose();
return(null);
}
string s = drd.GetString(0);
drd.Dispose();
int i1 = s.ToLower().IndexOf(aSymbol.ToLower()); // find atom symbol
if (i1 < 0)
{
return(null);
}
s = s.Substring(i1 + 2); // get following number
i1 = s.IndexOf(" "); // and any following space
if (i1 >= 0)
{
s = s.Substring(0, i1);
}
return(Double.Parse(s));
}
/// <summary>
/// Select structures for a list of compound ids using a single SQL cursor.
/// </summary>
/// <param name="notInCache"></param>
/// <param name="mt"></param>
/// <param name="strMc"></param>
static Dictionary <string, MoleculeMx> SelectChemicalStructuresForCorpIdList(
List <string> cidList,
MetaTable mt)
{
List <string> notInCacheKeyList;
Dictionary <Int64, string> intKeyToStringKey;
DbType parmType;
MoleculeMx cs;
Int64 intCid;
string cid;
int li;
Stopwatch sw = Stopwatch.StartNew();
Dictionary <string, MoleculeMx> csDict = new Dictionary <string, MoleculeMx>();
List <string> notInCacheList = new List <string>();
// Get structures already in the cache
for (li = 0; li < cidList.Count; li++)
{
cid = cidList[li];
if (RestrictedDatabaseView.KeyIsRetricted(cid))
{
continue;
}
cid = CompoundId.Normalize(cid, mt);
if (!Int64.TryParse(cid, out intCid))
{
continue; // make sure an integer
}
if (MoleculeCache.Contains(cid)) // see if in cache
{
csDict[cid] = MoleculeCache.Get(cid);
continue;
}
else
{
notInCacheList.Add(cid);
}
}
// Retrieve structures from the database for those not in cache
if (notInCacheList.Count == 0)
{
return(csDict);
}
MetaColumn strMc = mt.GetMetaColumnByName("molstructure");
if (strMc == null)
{
return(null);
}
string tableMap = mt.GetTableMapWithAliasAppendedIfNeeded(); // some SQL (e.g. Postgres) requires an alias for subqueries)
string keyColName = mt.KeyMetaColumn.ColumnMap;
if (Lex.IsUndefined(keyColName))
{
keyColName = mt.KeyMetaColumn.Name;
}
string strColExpr = strMc.ColumnMap;
if (strColExpr == "")
{
strColExpr = strMc.Name;
}
if (MqlUtil.IsCartridgeMetaTable(mt)) // selecting from Direct cartridge
{
if (!Lex.Contains(tableMap, "chime(")) // if no chime expression
{
strColExpr = "chime(ctab)"; // then create one (gets clob)
}
strColExpr += ", chime(ctab)"; // add 2nd column that gets clob in case first just gets first 4000 characters
}
string sql =
"select " + keyColName + ", " + strColExpr + " " +
"from " + tableMap + " " +
"where " + keyColName + " in (<list>)";
DbCommandMx drd = new DbCommandMx();
bool isNumericKey = (mt.KeyMetaColumn.IsNumeric);
bool isStringKey = !isNumericKey;
if (isStringKey)
{
parmType = DbType.String;
}
else
{
parmType = DbType.Int64;
}
try
{
drd.PrepareListReader(sql, parmType);
drd.ExecuteListReader(notInCacheList);
while (drd.Read())
{
if (drd.Rdr.IsDBNull(0))
{
continue;
}
if (isNumericKey)
{
intCid = drd.GetLong(0);
cid = intCid.ToString();
}
else // string cid
{
cid = drd.GetString(0);
}
cid = CompoundId.Normalize(cid, mt);
string molString = drd.GetString(1);
cs = new MoleculeMx(MoleculeFormat.Chime, molString);
csDict[cid] = cs;
MoleculeCache.AddMolecule(cid, cs);
}
drd.Dispose();
int msTime = (int)sw.ElapsedMilliseconds;
return(csDict);
}
catch (Exception ex)
{
if (drd != null)
{
drd.Dispose();
}
throw new Exception(
"SelectStructuresForCorpIdList, table: " + mt.Name + "\n" +
"sql: " + OracleMx.FormatSql(sql) + "\n");
}
}
/// <summary>
/// Execute structure search for structures stored in an Oracle text column
/// </summary>
/// <param name="sql">Basic sql to select key & structure</param>
public void ExecuteInternalOracleStructureColumnSearch(
string sql,
MoleculeFormat structureFormat)
{
string cid, molString;
object[] vo;
MoleculeMx cs;
bool match = false;
QueryColumn molsimQc = Eqp.QueryTable.GetSelectedMolsimQueryColumn(); // get any column to return similarity score in
DbCommandMx drd = new DbCommandMx();
if (Eqp.SearchKeySubset == null)
{
drd.Prepare(sql);
drd.ExecuteReader();
}
else // limit to list
{
sql += " where " + Eqp.QueryTable.MetaTable.KeyMetaColumn.Name + " in (<list>)";
drd.PrepareListReader(sql, DbType.String);
List <string> dbKeySubset = new List <string>();
foreach (string key in Eqp.SearchKeySubset)
{
string dbKey = CompoundId.NormalizeForDatabase(key, Eqp.QueryTable.MetaTable);
dbKeySubset.Add(dbKey);
}
drd.ExecuteListReader(dbKeySubset);
}
drd.CheckForCancel = Eqp.CheckForCancel; // set cancel check flag
StructureMatcher matcher = new StructureMatcher(); // allocate structure matcher
List <object[]> results = new List <object[]>();
int matchCount = 0;
while (drd.Read())
{
cid = drd.GetObject(0).ToString();
cid = CompoundId.Normalize(cid, Eqp.QueryTable.MetaTable); // normalize adding prefix as needed
molString = drd.GetString(1);
if (String.IsNullOrEmpty(molString))
{
continue;
}
cs = new MoleculeMx(structureFormat, molString);
if (Pssc.SearchType == StructureSearchType.Substructure)
{
if (matcher.IsSSSMatch(Pssc.Molecule, cs))
{
vo = new object[SelectList.Count];
vo[0] = CompoundId.Normalize(cid, Eqp.QueryTable.MetaTable); // normalize adding prefix
results.Add(vo);
}
}
else if (Pssc.SearchType == StructureSearchType.MolSim)
{
double score = matcher.Molsim(Pssc.Molecule, cs, Pssc.SimilarityType);
if (score >= Pssc.MinimumSimilarity)
{
vo = new object[SelectList.Count];
vo[0] = CompoundId.Normalize(cid, Eqp.QueryTable.MetaTable); // normalize adding prefix
if (vo.Length >= 2)
{
vo[1] = (float)score;
}
results.Add(vo);
}
}
else if (Pssc.SearchType == StructureSearchType.FullStructure)
{
if (matcher.FullStructureMatch(Pssc.Molecule, cs, Pssc.Options))
{
vo = new object[SelectList.Count];
vo[0] = CompoundId.Normalize(cid, Eqp.QueryTable.MetaTable); // normalize adding prefix
results.Add(vo);
}
}
matchCount++;
// if (matchCount >100) break; // debug
if (drd.Cancelled)
{
Eqp.Qe.Cancelled = true;
drd.Dispose();
Results = null;
return;
}
}
drd.Dispose();
Results = results;
return;
}
/// <summary>
/// Select a Molecule object for a compound id
/// </summary>
/// <param name="cid"></param>
/// <param name="mt"></param>
/// <returns></returns>
public static MoleculeMx SelectMoleculeForCid(
string cid,
MetaTable mt = null)
{
MetaColumn strMc = null;
string mtName = null, keyColName, strColExpr, chimeString;
MoleculeMx cs;
if (cid == null || cid == "")
{
return(null);
}
if (RestrictedDatabaseView.KeyIsRetricted(cid))
{
return(null);
}
//if (mt != null) mtName = mt.Name; // debug
bool isUcdb = (mt != null && mt.Root.IsUserDatabaseStructureTable); // user compound database
if (isUcdb) // if root metatable is user database then normalize based on key
{
mt = mt.Root; // be sure we have root
cid = CompoundId.Normalize(cid, mt);
}
else
{
cid = CompoundId.Normalize(cid, mt);
cs = MoleculeCache.Get(cid); // see if in cache
if (cs != null)
{
return(cs);
}
mt = CompoundId.GetRootMetaTableFromCid(cid, mt);
if (mt != null && Lex.Eq(mt.Name, "corp_structure") && MetaTableCollection.Get("corp_structure2") != null)
{
mt = MetaTableCollection.Get("corp_structure2"); // hack to search both small & large mols for Corp database
}
}
if (mt == null)
{
return(null);
}
strMc = mt.FirstStructureMetaColumn; //.getmt.GetMetaColumnByName("molstructure");
if (strMc == null)
{
return(null);
}
cid = CompoundId.NormalizeForDatabase(cid, mt);
if (String.IsNullOrEmpty(cid))
{
return(null);
}
// Call external method to select structure
if (strMc.ColumnMap.StartsWith("InternalMethod", StringComparison.OrdinalIgnoreCase) ||
strMc.ColumnMap.StartsWith("PluginMethod", StringComparison.OrdinalIgnoreCase))
{ // call external method to get structure
List <MetaColumn> selectList = new List <MetaColumn>();
selectList.Add(mt.KeyMetaColumn);
selectList.Add(strMc);
object[] vo = new object[2];
vo[0] = cid;
try { GenericMetaBroker.CallLateBindMethodToFillVo(vo, 1, mt, selectList); }
catch (Exception ex)
{ return(null); }
if (vo[1] is MoleculeMx)
{
cs = (MoleculeMx)vo[1];
}
else if (vo[1] is string)
{
cs = MoleculeMx.MolStringToMoleculeMx((string)vo[1]);
}
else
{
cs = null;
}
if (!isUcdb)
{
MoleculeCache.AddMolecule(cid, cs);
}
return(cs);
}
// Normal case
//if (HelmEnabled) // temp till server back
//{
// cs = new MoleculeMx();
// MoleculeMx.SetMoleculeToTestHelmString(cid, cs);
// return cs;
//}
string tableMap = mt.GetTableMapWithAliasAppendedIfNeeded(); // some SQL (e.g. Postgres) requires an alias for subqueries)
strColExpr = strMc.ColumnMap;
if (strColExpr == "")
{
strColExpr = strMc.Name;
}
if (MqlUtil.IsCartridgeMetaTable(mt)) // selecting from Direct cartridge
{
if (!Lex.Contains(tableMap, "chime(")) // if no chime expression
{
strColExpr = "chime(ctab)"; // then create one (gets clob)
}
strColExpr += ", chime(ctab)"; // add 2nd column that gets clob in case first just gets first 4000 characters
}
keyColName = mt.KeyMetaColumn.ColumnMap;
if (keyColName == "")
{
keyColName = mt.KeyMetaColumn.Name;
}
DbType parmType = DbType.String;
object cidObj = cid;
if (mt.KeyMetaColumn.IsNumeric)
{
if (!Lex.IsInteger(cid))
{
return(null); // if numeric col be sure cid is numeric also
}
parmType = DbType.Int64;
cidObj = Int64.Parse(cid);
}
string sql =
"select " + strColExpr + " " +
"from " + tableMap + " " +
"where " + keyColName + " = :0";
DbCommandMx drd = new DbCommandMx();
try
{
drd.PrepareParameterized(sql, parmType);
drd.ExecuteReader(cidObj);
if (!drd.Read() || drd.Rdr.IsDBNull(0))
{
drd.Dispose();
return(null);
}
string molString = drd.GetString(0);
drd.Dispose();
MoleculeMx.TrySetStructureFormatPrefix(ref molString, strMc.DataTransform); // add molString type if indicated by data transform
cs = MoleculeMx.MolStringToMoleculeMx(molString);
cs.StoreKeyValueInMolComments(strMc, cid);
if (!isUcdb)
{
MoleculeCache.AddMolecule(cid, cs);
}
//if (MoleculeMx.HelmEnabled == true && Lex.IsInteger(cid))
// MoleculeMx.SetMoleculeToTestHelmString(cid, cs);
return(cs);
}
catch (Exception ex)
{ // just log message & return;
DebugLog.Message("SelectMoleculeForCid Exception, Cid: " + cid + ", table: " + mt.Name + "\n" +
"sql: " + OracleMx.FormatSql(sql) + "\n" + DebugLog.FormatExceptionMessage(ex));
if (drd != null)
{
drd.Dispose();
}
return(null);
}
}
public static void UpdateFingerprintFiles()
{
string msg = "";
long uci, lastUci = 0;
int baseFpWriteCnt = 0, fragFpWriteCnt = 0, nullFpCnt = 0, readCnt = 0;
int fi = 0;
string sql = @"
select
x.uci,
x.src_id,
x.src_compound_id,
x.src_compound_id_nbr,
s.fingerprint,
h.fingerprint
from
DEV_MBS_OWNER.CORP_UC_XREF x,
DEV_MBS_OWNER.CORP_UC_STRUCTURE s,
DEV_MBS_OWNER.CORP_UC_FIKHB_HIERARCHY h
where
s.uci = x.uci
and H.PARENT (+) = s.fikhb
/* and s.uci between 1 and 1000 */ /* debug */
order by s.uci" ;
ShowProgress("Executing select fingerprints query...");
DbCommandMx cmd = DbCommandMx.PrepareExecuteAndRead(sql);
if (cmd == null)
{
throw new Exception("No rows retrieved");
}
bool readOk = true;
BinaryWriter[] bw = FpDao.OpenFingerprintFilesForWriting();
fi = 0;
DateTime lastProgressUpdate = DateTime.Now;
while (true)
{
if (readCnt > 0) // read next row if not first row
{
readOk = cmd.Read();
}
if (readOk)
{
readCnt++;
}
if (DateTime.Now.Subtract(lastProgressUpdate).TotalSeconds > 1 || !readOk) // show progress
{
lastProgressUpdate = DateTime.Now;
int fpWriteCnt = baseFpWriteCnt + fragFpWriteCnt;
msg =
"Update Fingerprint Files\r\n" +
"\r\n" +
"Reads: " + readCnt + "\r\n" +
"Fingerprints written: " + fpWriteCnt + "\r\n" +
"Null FPs: " + nullFpCnt;
ShowProgress(msg);
}
if (!readOk)
{
break;
}
uci = cmd.GetLong(0);
int src = cmd.GetInt(1);
string cidString = cmd.GetString(2);
int cidInt = cmd.GetInt(3);
byte[] fp = cmd.GetBinary(4);
byte[] fp2 = cmd.GetBinary(5);
if (fp == null && fp2 == null)
{
nullFpCnt++;
continue;
}
if (uci != lastUci)
{
fi = (fi + 1) % FpDao.FingerprintFileCount;
lastUci = uci;
}
if (fp != null)
{
FpDao.WriteFingerprintRec(bw[fi], uci, src, cidString, fp);
baseFpWriteCnt++;
}
if (fp2 != null)
{
FpDao.WriteFingerprintRec(bw[fi], uci, src, cidString, fp2);
fragFpWriteCnt++;
}
} // read loop
cmd.CloseReader();
FpDao.CloseFingerprintFilesForWriting();
FpDao.BackupAndReplaceFingerprintFiles();
msg = "*** Update Complete ***\r\n\r\n" + msg;
ShowProgress(msg);
return;
}
static ICdkMol CdkMolUtil => StaticCdkMol.I; // static molecule shortcut for utility methods
/// <summary>
/// UpdateCorpFingerprintDatabaseMx
/// ///////////////////////////////////////////////////////
/// Syntax: Update FingerprintDatabaseMx [Corp | ChEMBL] [MACCS | ECFP4] [Load | ByCidRange | SinceLastCheckpoint | LoadMissing | <SingleCorpId>]
///
/// Corp Examples:
/// Update FingerprintDatabaseMx Corp MACCS Load
/// Update FingerprintDatabaseMx Corp MACCS LoadMissing
/// Update FingerprintDatabaseMx Corp MACCS SinceLastCheckpoint
///
/// Update FingerprintDatabaseMx Corp ECFP4 Load
/// Update FingerprintDatabaseMx Corp ECFP4 LoadMissing
/// Update FingerprintDatabaseMx Corp ECFP4 SinceLastCheckpoint
///
/// ChEMBL Examples:
/// Update FingerprintDatabaseMx Chembl MACCS Load
/// Update FingerprintDatabaseMx Chembl MACCS LoadMissing
///
/// Update FingerprintDatabaseMx Chembl ECFP4 Load
/// Update FingerprintDatabaseMx Chembl ECFP4 LoadMissing
/// ///////////////////////////////////////////////////////
/// </summary>
/// <param name="argString"></param>
/// <returns></returns>
static public string Update(
string argString)
{
MoleculeMx mol;
double mw;
string chime, smiles, molString, molFile = "";
string msg = "", sql = "", chemblId, cid = "", maxCorpIdSql, maxIdSql2, mf, missingFixCriteria = "", CorpIdList = "";
int storeChunkCount = 0, CorpId, molregno, molId, lowId = 0, highId = 0, maxDestId = 0, maxSrcId = 0;
int readCount = 0, storeCount = 0;
ByCheckpoint = ByCidRange = ByCidList = LoadIfMissing = false;
ReadChunkSize = DefaultReadChunkSize;
WriteChunkSize = DefaultWriteChunkSize;
Failures = new Dictionary <string, string>();
NewUndefinedStructureCids = new List <string>();
LastFailure = "";
FailureCount = 0;
// global try loop
try
{
////////////////////////
/// Parse Parameters ///
////////////////////////
// See which database
argString = argString.Trim();
if (Lex.StartsWith(argString, "Corp"))
{
Database = "Corp";
argString = argString.Substring(5).Trim();
}
else if (Lex.StartsWith(argString, "Chembl"))
{
Database = "ChEMBL";
argString = argString.Substring(6).Trim();
}
else
{
return(SyntaxMsg);
}
// See which fingerprint type
FingerprintType = FingerprintType.MACCS; // default to MACCS if type not defined
if (Lex.TryReplace(ref argString, "MACCS", ""))
{
FingerprintType = FingerprintType.MACCS;
argString = argString.Trim();
}
else if (Lex.TryReplace(ref argString, "ECFP4", ""))
{
FingerprintType = FingerprintType.Circular; // (i.e. ECFP4)
argString = argString.Trim();
}
FpDao = new FingerprintDao(Database, FingerprintType);
List <FingerprintRec> fpRecList = new List <FingerprintRec>();
string args = argString.Trim();
string initialMsg = "Update FingerprintDatabase started: " + args;
CidList = new List <string>(); // init empty list
//////////////////////
/// Corp Database ///
//////////////////////
if (CorpDatabase)
{
if (Lex.Eq(args, "Load"))
{
ByCidRange = true;
ShowProgress("Getting range of CorpIds to insert...");
maxCorpIdSql = SelectMaxCorpId; // get highest id in source db
maxSrcId = SelectSingleValueDao.SelectInt(maxCorpIdSql);
if (maxSrcId < 0)
{
maxSrcId = 0;
}
maxDestId = GetMaxDestMolId();
//maxIdSql2 = "select max(src_compound_id_nbr) from dev_mbs_owner.corp_uc_xref where src_id = 0"; // get highest id in UniChemDb db
//highCorpId = SelectSingleValueDao.SelectInt(maxIdSql2);
if (maxDestId < 0)
{
maxDestId = 0;
}
}
else if (Lex.Eq(args, "SinceLastCheckpoint"))
{
ByCheckpoint = true;
ShowProgress("Getting list of CorpIds updated since last checkpoint...");
CidList = GetNewAndModifiedCorpIdList(out CidUpdateDateDict);
//CidUpdateList = new List<string>(); // debug with single cmpd
//CidUpdateList.Add("03435269");
if (CidList.Count == 0)
{
return("There have been no updates since the last checkpoint");
}
initialMsg += ", CorpIds to add/update: " + CidList.Count;
}
else if (Lex.StartsWith(args, "ByCorpIdList"))
{
ByCidList = true;
CorpIdList = args.Substring("ByCorpIdList".Length).Trim();
if (Lex.IsUndefined(CorpIdList))
{
throw new Exception("Undefined CorpId list");
}
}
else if (Lex.StartsWith(args, "LoadMissing"))
{
LoadIfMissing = true;
if (args.Contains(" "))
{
missingFixCriteria = args.Substring("LoadMissing".Length).Trim();
}
ShowProgress("Getting list of missing CorpIds...");
CidList = GetMissingCidList();
if (CidList.Count == 0)
{
return("There are no missing CorpIds");
}
initialMsg += ", Missing CorpIds: " + CidList.Count;
}
else if (int.TryParse(args, out maxSrcId)) // single CorpId
{
ByCidRange = true;
maxDestId = maxSrcId - 1; // say 1 less is the max we have
}
else
{
return(SyntaxMsg);
}
}
///////////////////////
/// ChEMBL Database ///
///////////////////////
else if (ChemblDatabase)
{
if (Lex.Eq(args, "Load"))
{
ByCidRange = true;
ShowProgress("Getting range of MolRegNos to insert...");
sql = "select max(molregno) from chembl_owner.compound_struct_xxxxxx";
maxSrcId = SelectSingleValueDao.SelectInt(sql);
if (maxSrcId < 0)
{
maxSrcId = 0;
}
maxDestId = GetMaxDestMolId();
if (maxDestId < 0)
{
maxDestId = 0;
}
}
else if (Lex.StartsWith(args, "LoadMissing"))
{
LoadIfMissing = true;
ShowProgress("Getting list of missing ChEMBL Ids...");
CidList = GetMissingCidList();
if (CidList.Count == 0)
{
return("There are no missing Ids");
}
initialMsg += ", Missing Chembl Ids: " + CidList.Count;
}
else
{
return(SyntaxMsg);
}
}
else
{
return(SyntaxMsg);
}
CidListOriginalCount = CidList.Count;
Log(initialMsg);
/////////////////////////////
// Loop over chunks of data
/////////////////////////////
for (int chunk = 1; ; chunk++)
{
//////////////////////
/// Corp Database ///
//////////////////////
if (CorpDatabase)
{
if (ByCheckpoint) // single chunk
{
string cidList = GetNextListChunk();
if (Lex.IsUndefined(cidList))
{
break;
}
sql = SelectByCorpIdCriteria;
sql = Lex.Replace(sql, "<CorpIdCriteria>", "in (" + cidList + ")");
string matchString = "order by m.corp_nbr";
if (!Lex.Contains(sql, matchString))
{
throw new Exception(matchString + " not found");
}
sql = Lex.Replace(sql, matchString, "order by m.molecule_date");
msg = "Processing " + CidListOriginalCount + " updates since " + CheckpointDateTime;
// + " (" + Mobius.Data.CidList.FormatCidListForDisplay(null, chunkCidList) + ")";
}
else if (ByCidRange) // by CorpId range
{
if (maxDestId >= maxSrcId)
{
break; // done
}
lowId = maxDestId + 1; // start of next chunk
highId = lowId + ReadChunkSize;
maxDestId = highId;
//lowCorpId = highCorpId = 12345; // debug
if (highId >= maxSrcId)
{
highId = maxSrcId;
}
sql = SelectByCorpIdCriteria;
sql = Lex.Replace(sql, "<CorpIdCriteria>", "between " + lowId + " and " + highId);
msg = "Processing CorpId range: " + lowId + " to " + highId;
}
else if (ByCidList) // by single user-supplied CorpId list
{
if (chunk > 1)
{
break; // break 2nd time through
}
sql = SelectByCorpIdCriteria;
sql = Lex.Replace(sql, "<CorpIdCriteria>", "in (" + CorpIdList + ")");
msg = "Processing CorpId list: " + CorpIdList;
}
else if (LoadIfMissing)
{
string cidList = GetNextListChunk();
if (Lex.IsUndefined(cidList))
{
break; // all done
}
sql = SelectByCorpIdCriteria;
sql = Lex.Replace(sql, "<CorpIdCriteria>", "in (" + cidList + ")");
msg = "Processing missing CorpId Chunk: " + Mobius.Data.CidList.FormatAbbreviatedCidListForDisplay(null, cidList) +
", Total Ids: " + CidListOriginalCount;
Log(msg);
}
else
{
return(SyntaxMsg);
}
}
///////////////////////
/// ChEMBL Database ///
///////////////////////
else if (ChemblDatabase)
{
if (ByCidRange) // by CID range
{
if (maxDestId >= maxSrcId)
{
break; // done
}
lowId = maxDestId + 1; // start of next chunk
highId = lowId + ReadChunkSize;
maxDestId = highId;
//lowId = highId = 12345; // debug
if (maxDestId >= maxSrcId)
{
maxDestId = maxSrcId;
}
sql = SelectChemblSql;
sql = Lex.Replace(sql, "<molregnoCriteria>", "between " + lowId + " and " + highId);
msg = "Processing ChEMBL MolRegNo range: " + lowId + " to " + highId;
}
else if (LoadIfMissing)
{
string cidList = GetNextListChunk();
if (Lex.IsUndefined(cidList))
{
break; // all done
}
sql = SelectByCorpIdCriteria;
sql = Lex.Replace(sql, "<CorpIdCriteria>", "in (" + cidList + ")");
msg = "Processing missing ChEMBL Id Chunk: " + Mobius.Data.CidList.FormatAbbreviatedCidListForDisplay(null, cidList) +
", Total Ids: " + CidListOriginalCount;
}
else
{
return(SyntaxMsg);
}
}
else
{
return(SyntaxMsg);
}
ShowProgress(msg);
// Execute the SQL to get the rows for the chunk
DbCommandMx rdr = DbCommandMx.PrepareAndExecuteReader(sql);
DateTime lastShowProgressTime = DateTime.MinValue;
///////////////////////////////////////////
/// Loop over rows in the current chunk ///
///////////////////////////////////////////
while (true)
{
// Update progress display
if (DateTime.Now.Subtract(lastShowProgressTime).TotalSeconds > 1) // show progress
{
int storeTotalCount = storeCount + storeChunkCount;
string msg2 = msg + "\r\n" +
"Reads: " + readCount + "\r\n" +
"Undefined: " + NewUndefinedStructureCids.Count + "\r\n" +
"Insert/Updates: " + storeTotalCount + "\r\n" +
"Failures: " + FailureCount + "\r\n" +
"Failure Types: " + Failures.Count + "\r\n" +
"Last Failure: " + LastFailure;
ShowProgress(msg2);
lastShowProgressTime = DateTime.Now;
}
// Read and process next compound
bool readOk = rdr.Read();
if (readOk)
{
readCount++;
try
{
double t1 = 0, t2 = 0, t3 = 0, t4 = 0;
DateTime t0 = DateTime.Now;
mol = null;
//t2 = TimeOfDay.Delta(ref t0);
//////////////////////
/// Corp Database ///
//////////////////////
if (CorpDatabase)
{
CorpId = rdr.GetInt(0); // corp_nbr
//Log("CorpId: " + CorpId); // debug
molId = CorpId;
cid = CorpId.ToString();
cid = CompoundId.NormalizeForDatabase(cid);
if (!rdr.IsNull(1)) // be sure chime field isn't null
{
chime = rdr.GetClob(1);
if (Lex.IsDefined(chime))
{
molFile = MoleculeMx.ChimeStringToMolfileString(chime); // convert Chime to MolFile
mol = new MoleculeMx(MoleculeFormat.Molfile, molFile);
}
}
MoleculeDateTime = rdr.GetDateTimeByName("Molecule_Date"); // Date molecule was updated in the CorpDB cartridge DB
}
///////////////////////
/// ChEMBL Database ///
///////////////////////
else // chembl
{
molId = molregno = rdr.GetInt(0);
cid = chemblId = rdr.GetString(1);
smiles = rdr.GetString(2);
if (Lex.IsDefined(smiles))
{
mol = new MoleculeMx(MoleculeFormat.Smiles, smiles);
}
}
if (MoleculeMx.IsUndefined(mol) || mol.AtomCount <= 1)
{
NewUndefinedStructureCids.Add(cid);
continue;
//mol = new AtomContainer(); // write empty structure
}
bool includeOverallFingerprint = true;
List <BitSetFingerprint> fps = CdkMol.BuildBitSetFingerprints(mol.MolfileString, includeOverallFingerprint, FingerprintType);
//t3 = TimeOfDay.Delta(ref t0);
foreach (BitSetFingerprint fp in fps)
{
FingerprintRec fpr = new FingerprintRec();
fpr.molId = molId;
fpr.SrcId = SrcDbId;
fpr.Cid = cid;
fpr.Cardinality = fp.cardinality();
fpr.Fingerprint = fp.asBitSet().toLongArray();
fpRecList.Add(fpr);
}
//t4 = TimeOfDay.Delta(ref t0);
t4 = t4;
}
catch (Exception ex)
{
if (!Failures.ContainsKey(ex.Message))
{
Failures.Add(ex.Message, cid);
}
else
{
Failures[ex.Message] += ", " + cid;
}
LastFailure = "Cid: " + cid + " - " + ex.Message;
Log(LastFailure);
//ShowProgress(ex.Message + "\r\n" + ex.StackTrace.ToString()); // debug
FailureCount++;
continue;
}
storeChunkCount++;
}
bool commitTransaction = (storeChunkCount >= WriteChunkSize || (!readOk && storeChunkCount > 0));
if (commitTransaction) // end of chunk of data to store?
{
// if updating by CheckPoint date range then merge existing data with new/updated data
if (ByCheckpoint)
{
if (readCount > 0 && (storeCount > 0 || FailureCount == 0)) // make sure not everything has failed)
{
MergeRecordsIntoFiles(fpRecList);
}
}
// Simple append of records to files
else
{
FpDao.OpenWriters("bin", FileMode.Append); // open bin files for append
foreach (FingerprintRec fpr in fpRecList) // write out buffered recs
{
FpDao.WriteFingerprintRec(fpr);
}
FpDao.CloseWriters();
int cnt = fpRecList.Count;
if (cnt > 0)
{
string cid1 = fpRecList[0].Cid;
string cid2 = fpRecList[cnt - 1].Cid;
Log("Records Appended: " + cnt + ", CIDS: " + cid1 + " - " + cid2);
}
else
{
Log("Records Appended: 0");
}
}
fpRecList.Clear();
storeCount += storeChunkCount;
storeChunkCount = 0;
}
if (!readOk)
{
break;
}
} // end of read loop for rows in a chunk
rdr.Dispose();
} // end for loop of chunks
DeleteTempFiles();
if (LoadIfMissing) // update list of cids with missing structures
{
ExistingUndefinedStructureCids.UnionWith(NewUndefinedStructureCids);
FpDao.WriteUndefinedStructuresCids(ExistingUndefinedStructureCids);
}
msg = "*** Update Complete ***\r\n\r\n" + msg;
ShowProgress(msg);
System.Threading.Thread.Sleep(100);
string logMsg = "UpdateFingerprintDb - CIDs stored: " + storeCount + ", Undefined structures: " + NewUndefinedStructureCids.Count + ", failures: " + FailureCount + "\r\n";
foreach (string key in Failures.Keys)
{
logMsg += key + " - CIDs: " + Failures[key] + "\r\n";
}
Log(logMsg);
return(logMsg);
} // end of main try loop
catch (Exception ex)
{
Log(DebugLog.FormatExceptionMessage(ex));
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Read next record
/// </summary>
/// <returns></returns>
public AnnotationVo Read()
{
if (!DbCmd.Read())
{
return(null);
}
AnnotationVo vo = new AnnotationVo();
vo.rslt_id = DbCmd.GetLong(0);
vo.rslt_grp_id = DbCmd.GetLong(1);
vo.ext_cmpnd_id_txt = DbCmd.GetString(2);
vo.ext_cmpnd_id_nbr = DbCmd.GetInt(3);
vo.src_db_id = DbCmd.GetInt(4);
vo.mthd_vrsn_id = DbCmd.GetInt(5);
vo.rslt_typ_id = DbCmd.GetLong(6);
vo.rslt_val_prfx_txt = DbCmd.GetString(7);
vo.rslt_val_nbr = DbCmd.GetDouble(8);
vo.uom_id = DbCmd.GetInt(9);
vo.rslt_val_txt = DbCmd.GetString(10);
vo.rslt_val_dt = DbCmd.GetDateTime(11);
vo.cmnt_txt = DbCmd.GetString(12);
vo.dc_lnk = DbCmd.GetString(13);
vo.chng_op_cd = DbCmd.GetString(14);
vo.chng_usr_id = DbCmd.GetString(15);
return(vo);
}
/// <summary>
/// Read in data, pivot & buffer for supplied set of rows.
/// This is called for retrieval only, not for search
/// </summary>
/// <param name="eqp"></param>
public override void ExecuteQuery(
ExecuteQueryParms eqp)
{
DbCommandMx drd;
int rowsFetched = 0, vosCreated = 0;
MetaTable mt;
MetaColumn mc = null;
DateTime dt;
PivotMetaBroker mb;
List <GenericMetaBroker> mbList;
string cid, pivotKey, tableFilter, s, txt, tok;
int fci, mci, pvi, pci, si, i1;
object[] vo = null;
object o;
if (!PivotInCode) // let Oracle do the pivoting?
{
base.ExecuteQuery(eqp);
return;
}
// Self-pivot. Read & buffer data for all query tables from same Source/TableFilterColumns for key set if we are the first table for Source
int t0 = TimeOfDay.Milliseconds();
Dictionary <string, MultiTablePivotBrokerTypeData> mbsi = eqp.Qe.MetaBrokerStateInfo;
mt = eqp.QueryTable.MetaTable;
string sourceKey = mt.TableMap + "," + Csv.JoinCsvString(mt.TableFilterColumns); // grouping based on source sql
MultiTablePivotBrokerTypeData mpd = (MultiTablePivotBrokerTypeData)mbsi[sourceKey];
if (mpd.FirstTableName != mt.Name)
{
return; // retrieve data for all tables when we see first table
}
mpd.ClearBuffers();
// Build sql
StringBuilder sb = new StringBuilder(); // build filter to select for desired metatable
tableFilter = "";
if (mt.TableFilterColumns.Count == 1)
{ // build single in list if single filter column
foreach (string mtName in mpd.MbInstances.Keys)
{
mt = MetaTableCollection.Get(mtName);
if (sb.Length > 0)
{
sb.Append(",");
}
sb.Append(mt.TableFilterValues[0]);
tableFilter = mt.TableFilterColumns[0] + " in (" + sb.ToString() + ")";
}
}
else // multiple table filter columns, build and/or expressions
{
foreach (string mtName in mpd.MbInstances.Keys)
{
mt = MetaTableCollection.Get(mtName);
if (sb.Length > 0)
{
sb.Append(" or ");
}
tableFilter = "(" + GetTableFilterCriteria(mt) + ")";
sb.Append(tableFilter);
}
tableFilter = "(" + sb.ToString() + ")";
}
string sql = "select * from " + mt.TableMap + " where ";
if (tableFilter != "")
{
sql += tableFilter + " and ";
}
sql += mt.KeyMetaColumn.ColumnMap + " in (<list>) ";
// Read unpivoted data, merge/pivot & buffer pivoted rows
List <string> keySubset = eqp.SearchKeySubset;
if (keySubset == null)
{
keySubset = GetPreviewSubset(); // assume previewing of single table if no subset
}
List <string> parmList = new List <string>();
for (i1 = 0; i1 < keySubset.Count; i1++) // copy keys to parameter array properly normalized
{
string key = CompoundId.NormalizeForDatabase((string)keySubset[i1], Qt.MetaTable);
if (key != null)
{
parmList.Add(key);
}
}
drd = new DbCommandMx();
drd.PrepareListReader(sql, DbType.String);
drd.ExecuteListReader(parmList);
while (drd.Read())
{
rowsFetched++;
string tableFilterKey = ""; // get column values to identify table
for (fci = 0; fci < mt.TableFilterColumns.Count; fci++)
{
o = drd.GetObjectByName(mt.TableFilterColumns[fci]);
if (o == null)
{
s = "";
}
else
{
s = o.ToString();
}
if (tableFilterKey != "")
{
tableFilterKey += ", ";
}
tableFilterKey += s;
}
mt = mpd.TableFilterValuesToMetaTableDict[tableFilterKey];
if (mt == null)
{
continue; // continue if don't know about this table
}
if (!mpd.MbInstances.ContainsKey(mt.Name))
{
continue; // have row hash for broker?
}
int mbIdx = 0;
mb = (PivotMetaBroker)mpd.GetFirstBroker(mt.Name, out mbList);
while (true) // copy out for each metabroker
{
mt = mb.Qt.MetaTable;
if (mt == null)
{
continue;
}
if (mb.MultipivotRowDict == null)
{
mb.MultipivotRowDict = new Dictionary <string, object[]>();
}
string rowKey = "";
for (mci = 0; mci < mt.PivotMergeColumns.Count; mci++)
{
o = drd.GetObjectByName(mt.PivotMergeColumns[mci]);
if (o == null)
{
s = "<null>";
}
else
{
s = o.ToString();
}
rowKey += "<" + s + ">";
}
if (mb.MultipivotRowDict.ContainsKey(rowKey)) // have entry for row?
{
vo = (object[])mb.MultipivotRowDict[rowKey];
}
else // new row, create vo for it & fill in merged column values
{
vo = new Object[mb.SelectList.Count];
for (si = 0; si < mb.SelectList.Count; si++) // transfer non-pivoted values
{
mc = mb.SelectList[si];
if (mc.PivotValues != null)
{
continue; // skip pivoted cols for now
}
for (mci = 0; mci < mt.PivotMergeColumns.Count; mci++)
{
if (Lex.Eq(mc.ColumnMap, mt.PivotMergeColumns[mci]))
{
o = drd.GetObjectByName(mt.PivotMergeColumns[mci]);
if (mc.IsKey) // normalize cid adding prefix as needed
{
o = CompoundId.Normalize(o.ToString(), mt);
}
vo[si] = o;
break;
}
}
}
mb.MultipivotRowDict[rowKey] = vo;
vosCreated++;
}
// Pivot out data based on pivot column values
if (mb.PivotKeys == null)
{ // build set of pivot keys for the pivoted columns in the table if not done yet
mb.PivotKeys = new string[mb.SelectList.Count];
for (si = 0; si < mb.SelectList.Count; si++)
{
mc = mb.SelectList[si];
if (mc.PivotValues == null)
{
continue; // skip non-pivoted cols
}
pivotKey = "";
for (pvi = 0; pvi < mc.PivotValues.Count; pvi++)
{
pivotKey += "<" + mc.PivotValues[pvi].ToLower() + ">";
}
mb.PivotKeys[si] = pivotKey;
}
}
pivotKey = "";
for (pci = 0; pci < mt.PivotColumns.Count; pci++)
{ // build pivot key for this unpivoted row
o = drd.GetObjectByName(mt.PivotColumns[pci]);
if (o == null)
{
s = "<null>";
}
else
{
s = o.ToString().ToLower();
}
pivotKey += "<" + s + ">";
}
for (si = 0; si < mb.SelectList.Count; si++) // transfer pivoted values
{
if (mb.PivotKeys[si] == null || // skip non-pivoted cols
pivotKey != mb.PivotKeys[si])
{
continue; // and non-matches
}
mc = mb.SelectList[si];
int ci = drd.Rdr.GetOrdinal(mc.ColumnMap);
if (mc.DataType == MetaColumnType.Integer)
{
if (!mc.DetailsAvailable) // simple scalar value
{
vo[si] = drd.GetInt(ci);
}
else // value with possible resultId, linking information
{
txt = drd.GetString(ci); // todo: fix for annotation
vo[si] = QueryEngine.ParseScalarValue(txt, Qt, mc);
}
}
else if (mc.DataType == MetaColumnType.Number)
{
if (!mc.DetailsAvailable) // simple scalar value
{
vo[si] = drd.GetDouble(ci);
}
else // value with possible resultId, linking information
{
txt = Dr.GetString(ci); // todo: fix for annotation
vo[si] = QueryEngine.ParseScalarValue(txt, Qt, mc);
}
}
else if (mc.DataType == MetaColumnType.QualifiedNo)
{
// todo
}
else if (mc.DataType == MetaColumnType.String)
{
if (!mc.DetailsAvailable)
{
vo[si] = drd.GetString(ci);
}
else // value with possible resultId, linking information
{
txt = Dr.GetString(ci); // todo: fix for annotation
vo[si] = QueryEngine.ParseScalarValue(txt, Qt, mc);
}
}
else if (mc.DataType == MetaColumnType.Date)
{
if (!mc.DetailsAvailable) // simple scalar value
{
vo[si] = drd.GetDateTime(ci);
}
else // value with possible resultId, linking information
{
txt = Dr.GetString(ci); // todo: fix for annotation
vo[si] = QueryEngine.ParseScalarValue(txt, Qt, mc);
}
}
else if (mc.DataType == MetaColumnType.Structure)
{ // structures come in as compound identifiers (todo: fix for annotation)
tok = Dr.GetValue(si).ToString();
cid = CompoundId.Normalize(tok, Qt.MetaTable);
vo[si] = cid;
}
else if (mc.DataType == MetaColumnType.MolFormula)
{
vo[si] = drd.GetString(ci);
}
else if (mc.DataType == MetaColumnType.DictionaryId)
{
try // Id may be string or integer value
{ vo[si] = drd.GetString(ci); }
catch (Exception ex)
{ vo[si] = drd.GetInt(ci); }
}
else if (mc.DataType == MetaColumnType.Image)
{
try // Id may be string or integer value
{ vo[si] = drd.GetString(ci); }
catch (Exception ex)
{ vo[si] = drd.GetInt(ci); }
}
else if (mc.DataType == MetaColumnType.Hyperlink)
{
txt = drd.GetString(ci);
Hyperlink hlink = new Hyperlink();
vo[si] = hlink;
hlink.Text = txt;
}
}
if (mbList == null)
{
break; // single broker
}
mbIdx++; // go to next broker
if (mbIdx >= mbList.Count)
{
break; // at end of brokers?
}
mb = (PivotMetaBroker)mbList[mbIdx];
} // end of broker loop
} // end of read loop
drd.Dispose();
return;
}
/// <summary>
/// SelectWithCriteria
/// </summary>
/// <param name="criteria"></param>
/// <returns></returns>
public static List <AfsLibrary> SelectWithCriteria(string criteria)
{
MetaTreeNode tempMtn = new MetaTreeNode(MetaTreeNodeType.Library);
StringBuilder sb = new StringBuilder(64);
string sql = @"
select
p.proj_id,
p.mbs_project_code,
proj_name,
p.mbs_dht_folder_code,
dht_folder_name,
platform_name,
lib_id,
lib_name,
lib_use
from
<mbs_owner>.afs_project p,
<mbs_owner>.afs_lib l
where
p.afs_current = 1
and p.mbs_project_code is not null
and l.afs_current = 1
and l.proj_id = p.proj_id
and <criteria>
order by upper(dht_folder_name), upper(proj_name), upper(lib_name)
" ;
sql = Lex.Replace(sql, "<mbs_owner>", AfsProject.AfsTableSchema);
sql = Lex.Replace(sql, "<criteria>", criteria);
List <AfsLibrary> libs = new List <AfsLibrary>();
DbCommandMx dao = new DbCommandMx();
dao.Prepare(sql);
dao.ExecuteReader();
string fileName = MetaTableFactory.MetaTableXmlFolder + @"\LibraryStats.txt";
Dictionary <string, MetaTableStats> libStats = new Dictionary <string, MetaTableStats>();
int libCount = MetaTableFactory.LoadMetaTableStats(fileName, libStats);
while (dao.Read())
{
AfsLibrary l = new AfsLibrary();
l.ProjId = dao.GetInt(0);
l.MbsProjectName = dao.GetString(1).ToUpper();
l.ProjectLabel = dao.GetString(2);
l.MbsDhtFolderName = dao.GetString(3).ToUpper();
l.DhtFolderLabel = dao.GetString(4).ToUpper();
l.Platform = dao.GetString(5).ToUpper();
l.LibId = dao.GetInt(6);
l.LibName = dao.GetString(7);
l.LibUse = dao.GetString(8).ToUpper();
string nodeName = "LIBRARY_" + l.LibId;
sb.Length = 0;
sb.Append(l.LibName);
sb.Append(" (");
if (!Lex.IsNullOrEmpty(l.LibUse))
{
sb.Append(l.LibUse);
sb.Append(", ");
}
sb.Append("Id: ");
sb.Append(l.LibId);
if (libStats.ContainsKey(nodeName))
{
tempMtn.Size = (int)libStats[nodeName].RowCount;
tempMtn.UpdateDateTime = libStats[nodeName].UpdateDateTime; // really create date
sb.Append(", ");
sb.Append(MetaTreeNode.FormatStatistics(tempMtn));
}
sb.Append(")");
l.LibLabel = sb.ToString();
libs.Add(l);
}
dao.CloseReader();
return(libs);
}
/// <summary>
/// Build platform / target / assay metatree
/// </summary>
public static void BuildPlatformMetaTree()
{
string assayId, assayDb;
string sql = @"
select gene_fmly, gene_symbl, assy_nm, assy_db, assy_id_txt
from mbs_owner.cmn_assy_atrbts
where gene_fmly is not null and gene_symbl is not null and assy_nm is not null
order by lower(gene_fmly), lower(gene_symbl), lower(assy_nm)" ;
sql = AssayAttributesDao.AdjustAssayAttrsTableName(sql);
try
{
DbCommandMx drd = new DbCommandMx();
drd.Prepare(sql);
drd.ExecuteReader();
string family = "";
string targetSymbol = "";
string assayName = "";
MetaTreeNode familyMtn = null, targetMtn = null, tsMtn = null, assayMtn = null;
while (drd.Read())
{
string nextFamily = drd.GetString(0);
if (Lex.Ne(family, nextFamily)) // get current family node
{
family = nextFamily;
string familyNodeName = "GFTA_" + family.Replace(" ", "_"); // build name to match node
familyMtn = MetaTreeFactory.GetNode(familyNodeName);
}
string nextTargetSymbol = drd.GetString(1);
// if (Lex.Eq(nextTargetSymbol, "Adr1a")) nextTargetSymbol = nextTargetSymbol; // debug
if (Lex.Ne(targetSymbol, nextTargetSymbol)) // add new target node if going to new target
{
targetSymbol = nextTargetSymbol;
targetMtn = new MetaTreeNode();
targetMtn.Type = MetaTreeNodeType.Target;
targetMtn.Name = "TGT_ASSYS_" + targetSymbol.ToUpper();
targetMtn.Label = targetSymbol;
targetMtn.Target = targetMtn.Name;
MetaTreeFactory.AddNode(targetMtn);
if (familyMtn != null)
{
familyMtn.Nodes.Add(targetMtn);
}
tsMtn = new MetaTreeNode(); // add node for summary view by gene symbol
tsMtn.Type = MetaTreeNodeType.MetaTable;
tsMtn.Name = MultiDbAssayDataNames.BasePivotTablePrefix + targetSymbol.ToUpper();
tsMtn.Label = targetSymbol + " Assay Results Summary";
tsMtn.Target = tsMtn.Name;
MetaTreeNode mtn2 = MetaTreeFactory.GetNode(tsMtn.Name); // node with this name already exist?
if (mtn2 == null)
{
MetaTreeFactory.AddNode(tsMtn); // add to tree if doesn't exist
}
else
{
tsMtn = mtn2; // use existing node otherwise since this label doesn't have priority
}
if (targetMtn != null)
{
targetMtn.Nodes.Add(tsMtn);
}
}
string nextAssayName = drd.GetString(2);
if (Lex.Ne(assayName, nextAssayName))
{
assayName = nextAssayName;
assayDb = drd.GetString(3);
assayId = drd.GetString(4);
assayMtn = new MetaTreeNode();
assayMtn.Type = MetaTreeNodeType.MetaTable;
assayMtn.Name = assayId;
assayMtn.Target = assayMtn.Name;
assayMtn.Label = assayName;
MetaTreeNode mtn2 = MetaTreeFactory.GetNode(assayMtn.Name); // node with this name already exist?
if (mtn2 == null)
{
MetaTreeFactory.AddNode(assayMtn); // add to tree if doesn't exist
}
else
{
assayMtn = mtn2; // use existing node otherwise since this label doesn't have priority
}
if (targetMtn != null)
{
targetMtn.Nodes.Add(assayMtn);
}
}
}
drd.CloseReader();
drd.Dispose();
}
catch (Exception ex)
{
DebugLog.Message("TargetAssayMetafactory.Build Error:\r\n" + DebugLog.FormatExceptionMessage(ex));
return;
}
}
/// <summary>
/// Get Assay data including biological target(s) & gene(s) for a single Assay or all Assays
/// </summary>
/// <param name="assayId">Assay to get data for or -1 to get for all assays</param>
/// <returns></returns>
public static Dictionary <int, AssayDbMetadata> GetAssayDbDict
(int assayId)
{
if (ForceAssayId)
{
assayId = ForcedAssayId;
}
else if (AssayTargetGeneDataDict != null)
{
return(AssayTargetGeneDataDict);
}
string sql = @"
SELECT <columns>
FROM <tables>
WHERE 1 = 1
and <conditions>" ;
DbCommandMx drd = new DbCommandMx();
if (assayId > 0) // get for single assay
{
sql = sql.Replace("1=1", "<keyColExpr> = :0");
drd.PrepareParameterized(sql, DbType.Int32);
drd.ExecuteReader(assayId);
}
else // get for all assays
{
drd.Prepare(sql);
drd.ExecuteReader();
}
Dictionary <int, AssayDbMetadata> dict = new Dictionary <int, AssayDbMetadata>();
if (ForceAssayId)
{
AssayTargetGeneDataDict = dict;
}
AssayDbMetadata assay = null;
AssayDbTarget target = null;
int currentAssayId = -1;
int currentTrgtId = -1;
while (true)
{
if (!drd.Read())
{
break;
}
assayId = drd.GetInt(0);
string assayName = drd.GetString(1);
string MthdVrsnMdTxt = drd.GetString(2);
if (currentAssayId < 0 || currentAssayId != assayId)
{
assay = new AssayDbMetadata();
assay.AssayId = assayId;
assay.Name = assayName;
if (Lex.Eq(MthdVrsnMdTxt, "Single Point")) // translate values
{
assay.SP = true;
}
else if (Lex.Eq(MthdVrsnMdTxt, "Conc./Dose Response Curve"))
{
assay.CRC = true;
}
dict[assayId] = assay;
currentAssayId = assayId;
currentTrgtId = -1;
}
int trgtId = drd.GetInt(3); // target id
if (currentTrgtId < 0 || currentTrgtId != trgtId)
{ // new target
target = new AssayDbTarget();
target.TargetId = trgtId;
target.TargetName = drd.GetString(4); // target name
target.TargetDesc = drd.GetString(5); // target desc
target.TargetTypeName = drd.GetString(6); // e.g. G protein coupled receptor
target.TargetTypeShortName = drd.GetString(7); // e.g. GPCR
assay.Targets.Add(target);
currentTrgtId = trgtId;
}
string geneId = drd.GetString(8);
if (String.IsNullOrEmpty(geneId))
{
continue;
}
AssayDbGene gene = new AssayDbGene();
gene.GeneId = geneId;
gene.GeneSymbol = drd.GetString(9);
target.Genes.Add(gene);
}
drd.Dispose();
return(dict);
}
TextReader GetAssayXml(
string aid)
{
TextReader rdr = null;
DbCommandMx dao = null;
string xml;
// Try to get from file first
if (PubChemAssayDirectory == null)
{
PubChemAssayDirectory = ServicesIniFile.Read("PubChemAssayDirectory");
}
if (PubChemAssayDirectory != "")
{
try
{
string fileName = PubChemAssayDirectory + @"\CSV\Description\" + aid + ".descr.xml";
StreamReader sr = new StreamReader(fileName);
xml = sr.ReadToEnd();
sr.Close();
if (String.IsNullOrEmpty(xml))
{
return(null);
}
return(new StringReader(xml));
}
catch (Exception ex) { }
}
// Try to get from table (new method)
string sql =
"select xml " +
"from mbs_owner.mbs_pbchm_assy_xml " +
"where aid = :0";
try
{
dao = new DbCommandMx();
dao.PrepareParameterized(sql, DbType.String);
dao.ExecuteReader(aid);
if (!dao.Read())
{
throw new Exception("Not found");
}
xml = dao.GetString(0);
dao.Dispose();
}
catch (Exception ex)
{
dao.Dispose();
return(null);
}
if (String.IsNullOrEmpty(xml))
{
return(null);
}
return(new StringReader(xml));
}
/// <summary>
/// Lookup a query by matching the supplied substring against the query name
/// </summary>
/// <param name="querySubString"></param>
/// <param name="msg"></param>
/// <returns></returns>
public static int FindQueryByNameSubstring(string querySubString, out string msg)
{
string objNm, ownrId, fldrNm;
int objId = -1, exactThisUser = -1, exactOtherUser = -1;
string sql =
"select obj_id, obj_nm, ownr_id, fldr_nm " +
"from mbs_owner.mbs_usr_obj " +
"where obj_typ_id = " + (int)UserObjectType.Query + " and lower (obj_nm) like lower('%" + querySubString + "%')";
DbCommandMx dao = new DbCommandMx();
dao.Prepare(sql);
dao.ExecuteReader();
msg = "";
System.Text.StringBuilder sb = new System.Text.StringBuilder();
int rowCnt = 0;
while (dao.Read())
{
objId = dao.GetInt(0);
objNm = dao.GetString(1);
ownrId = dao.GetString(2);
fldrNm = dao.GetString(3);
sb.AppendLine(objId + ": " + objNm + "." + ownrId + "." + fldrNm);
if (Lex.Eq(objNm, querySubString)) // exact match?
{
if (Lex.Eq(ownrId, Security.UserName))
{
if (exactThisUser == -1)
{
exactThisUser = objId;
}
else
{
exactThisUser = -2;
}
}
else
{
if (exactOtherUser == -1)
{
exactOtherUser = objId;
}
else
{
exactOtherUser = -2;
}
}
}
rowCnt++;
}
dao.Dispose();
if (rowCnt == 1)
{
return(objId); // if just one hit return its id
}
else if (exactThisUser > 0)
{
return(exactThisUser);
}
else if (exactThisUser == -1 && exactOtherUser > 0)
{
return(exactOtherUser);
}
else
{
if (rowCnt == 0)
{
msg = "No queries found";
}
else if (rowCnt > 1)
{
msg = "Multiple matches:\n\n" + sb.ToString();
}
return(-1);
}
}