Exemplo n.º 1
0
        /// <summary>
        /// Select a MoleculeMx 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)
        {
            MoleculeMx mol = null;
            Stopwatch  sw  = Stopwatch.StartNew();

            mol = MoleculeCache.Get(cid);             // see if molecule in cache
            if (mol != null)
            {
                return(mol);
            }

            if (ServiceFacade.UseRemoteServices)
            {
                string mtName = mt?.Name;

                Mobius.Services.Native.INativeSession       nativeClient = ServiceFacade.CreateNativeSessionProxy();
                Services.Native.NativeMethodTransportObject resultObject =
                    ServiceFacade.InvokeNativeMethod(nativeClient,
                                                     (int)Services.Native.ServiceCodes.MobiusCompoundUtilService,
                                                     (int)Services.Native.ServiceOpCodes.MobiusCompoundUtilService.SelectMoleculeFromCid,
                                                     new Services.Native.NativeMethodTransportObject(new object[] { cid, mtName }));            // , setStereoChemistryComments
                ((System.ServiceModel.IClientChannel)nativeClient).Close();

                if (resultObject == null)
                {
                    return(null);
                }
                byte[] ba = resultObject.Value as byte[];
                if (ba != null && ba.Length > 0)
                {
                    MobiusDataType mdt = MobiusDataType.DeserializeBinarySingle(ba);
                    mol = mdt as MoleculeMx;
                }
            }

            else
            {
                mol = QEL.MoleculeUtil.SelectMoleculeForCid(cid, mt);
            }

            if (MoleculeMx.IsDefined(mol))
            {
                bool isUcdb = (mt != null && mt.Root.IsUserDatabaseStructureTable);                 // user compound database
                if (!isUcdb)
                {
                    MoleculeCache.AddMolecule(cid, mol);                          // add to cache
                }
            }

            long ms = sw.ElapsedMilliseconds;

            return(mol);
        }
Exemplo n.º 2
0
        /// <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");
            }
        }
Exemplo n.º 3
0
        /// <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);
            }
        }