public static SqlString CanSmiles(SqlBinary molecule, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, 0);
}
return BingoCore.mangoSMILES(molecule.Value, true);
}
}
private static SqlInt32 _Match (SqlBinary target, SqlString query, SqlString options,
SqlString bingo_schema, string search_type,
bingoCallback prepare_match, bingoCallback process_matched)
{
using (BingoSession sessions = new BingoSession())
{
ContextFlags flags = 0;
if (options.Value.Contains("TAU"))
flags |= ContextFlags.TAU_RULES;
if (search_type == "SIM")
flags |= ContextFlags.FINGERPRINTS;
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, flags);
}
int res = BingoCore.lib.mangoSetupMatch(search_type, query.Value, options.Value);
if (res < 0)
throw new Exception(BingoCore.lib.bingoGetError());
if (prepare_match != null)
prepare_match();
res = BingoCore.lib.mangoMatchTarget(target.Value, target.Value.Length);
if (res == -2)
throw new Exception(BingoCore.lib.bingoGetError());
if (res == -1)
{
// can not use SqlContext.Pipe from inside the function,
// so just returning NULL without printing the error message
return SqlInt32.Null;
}
if (res == 1 && process_matched != null)
process_matched();
return new SqlInt32(res);
}
}
public static void ResetStatistics (SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
BingoCore.lib.bingoProfilingReset(true);
}
}
public static int GetBondCount (SqlBinary molecule, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
return BingoCore.lib.mangoGetBondCount(molecule.Value, molecule.Value.Length);
}
}
public static SqlString GetStatistics (SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
return BingoCore.bingoProfilingGetStatistics(true);
}
}
public static void FlushOperations (SqlString table_name, SqlString bingo_schema)
{
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
using (SqlConnection ext_conn = new SqlConnection("server=" + getServername(conn) +
";integrated security=true;database=" + conn.Database))
{
ext_conn.Open();
using (BingoSession session = new BingoSession())
{
BingoIndexData index_data = BingoIndexData.GetIndexData(conn,
bingo_schema.Value, table_name.Value, getSPID(conn));
if (index_data.locked)
{
string msg = String.Format("Chemical index for the table '{0}' is locked.", table_name);
BingoLog.logMessage(msg);
throw new Exception(msg);
}
index_data.flush(ext_conn);
}
}
}
}
public static void DropInvalidIndices (SqlString bingo_schema)
{
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
using (BingoSession session = new BingoSession())
{
BingoIndexData.DropAllIndices(conn, bingo_schema.Value, true);
}
}
}
// Method for executing abstract operation with BingoIndexData
private static void _ExecuteBingoOperation(SqlString bingo_schema,
bingoOperationDelegate operationDelegate,
bingoGetIndexDataDelegate getBingoDataDelegate, BingoOp op_flags)
{
string table_name = "<Undef>";
BingoIndexID id = null;
SqlConnection ext_conn = null;
try
{
using (SqlConnection ctx_conn = new SqlConnection("context connection=true"))
{
ctx_conn.Open();
SqlConnection conn = ctx_conn;
if ((op_flags & BingoOp.NON_CONTEXT_CONN) != 0)
{
string conn_string = String.Format(
"server={0};integrated security=true;database={1};enlist=false",
getServername(ctx_conn), ctx_conn.Database);
ext_conn = new SqlConnection(conn_string);
ext_conn.Open();
conn = ext_conn;
}
using (BingoSession session = new BingoSession())
{
BingoCore.lib.bingoProfilingReset(false);
BingoTimer timer = new BingoTimer("total");
BingoIndexData index_data = getBingoDataDelegate(ctx_conn, conn, bingo_schema);
table_name = index_data.id.FullTableName(ctx_conn);
id = index_data.id;
if (index_data.locked)
{
BingoLog.logMessage("Attempt to get locked index for the table {0}", table_name);
throw new Exception("Chemical index for the table '" + table_name + "' is locked");
}
if ((op_flags & BingoOp.LOCK_INDEX) != 0)
index_data.locked = true;
ContextFlags flags = ContextFlags.NTHREADS | ContextFlags.FINGERPRINTS;
if ((op_flags & BingoOp.LOAD_TAU_RULES) != 0)
flags |= ContextFlags.TAU_RULES;
if ((op_flags & BingoOp.LOAD_CMF) != 0)
flags |= ContextFlags.CMF;
prepareContext(ctx_conn, bingo_schema.Value, index_data.id.table_id, flags);
index_data.syncContextParameters(ctx_conn, bingo_schema.Value);
try
{
operationDelegate(ctx_conn, conn, index_data);
}
catch (Exception ex)
{
if ((Thread.CurrentThread.ThreadState & ThreadState.AbortRequested) != 0)
Thread.ResetAbort();
BingoLog.logMessage("Exception {0} in {1}:\n{2}", ex.Message, ex.Source, ex.StackTrace);
if ((op_flags & BingoOp.LOCK_INDEX) != 0)
index_data.locked = false;
if ((op_flags & BingoOp.DROP_ON_EXCEPTION) != 0)
BingoIndexData.DropIndexData(conn, bingo_schema.Value, id, false);
throw ex;
}
if ((op_flags & BingoOp.LOCK_INDEX) != 0)
index_data.locked = false;
timer.end();
if ((op_flags & BingoOp.NEED_STAT) != 0)
BingoLog.logMessage("Statistics for table {0}:\n{1}\n",
table_name, BingoCore.bingoProfilingGetStatistics(false));
}
}
}
finally
{
if ((Thread.CurrentThread.ThreadState & ThreadState.AbortRequested) != 0)
Thread.ResetAbort();
if (ext_conn != null)
ext_conn.Close();
}
}
public static SqlString Rxnfile(SqlBinary reaction, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
ContextFlags flags = ContextFlags.X_PSEUDO | ContextFlags.IGNORE_CBDM;
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, flags);
}
return BingoCore.ringoRxnfile(reaction.Value);
}
}
public static SqlBinary CompactReaction (SqlBinary reaction, SqlBoolean save_xyz, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, 0);
}
return BingoCore.ringoICR(reaction.Value, save_xyz.Value);
}
}
public static SqlSingle Mass (SqlBinary molecule, SqlString type, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, 0);
}
float mass;
int ret = BingoCore.lib.mangoMass(molecule.Value, molecule.Value.Length, type.Value, out mass);
if (ret != 1)
return SqlSingle.Null;
return mass;
}
}
public static SqlBinary RFingerprint(SqlBinary reaction, SqlString options, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, ContextFlags.FINGERPRINTS);
}
return BingoCore.ringoFingerprint(reaction.Value, options.Value);
}
}
public static SqlString Rxnfile (SqlBinary reaction, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, 0);
}
return BingoCore.ringoRxnfile(reaction.Value);
}
}
public static SqlString InChIKey(SqlString inchi, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
return BingoCore.mangoInChIKey(inchi.Value);
}
}
private static SqlInt32 _RMatch (SqlBinary target, SqlString query, SqlString options,
SqlString bingo_schema, string search_type, bool heed_highlighting, ref string highlighting)
{
using (BingoSession sessions = new BingoSession())
{
ContextFlags flags = 0;
if (options.Value.Contains("TAU"))
flags |= ContextFlags.TAU_RULES;
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, flags);
}
int res = BingoCore.lib.ringoSetupMatch(search_type, query.Value, options.Value);
if (res < 0)
throw new Exception(BingoCore.lib.bingoGetError());
if (heed_highlighting)
BingoCore.lib.ringoSetHightlightingMode(1);
res = BingoCore.lib.ringoMatchTarget(target.Value, target.Value.Length);
if (res == -2)
throw new Exception(BingoCore.lib.bingoGetError());
if (res == -1)
{
// can not use SqlContext.Pipe from inside the function,
// so just returning NULL without printing the error message
return SqlInt32.Null;
}
if (res == 1 && heed_highlighting)
highlighting = BingoCore.ringoGetHightlightedReaction();
return new SqlInt32(res);
}
}
private static void _ImportData (string table_name, string data_column_name,
string additional_parameters, bingoImportPopulateDataRow populateRowFunc)
{
using (SqlConnection ctx_conn = new SqlConnection("context connection=true"))
{
ctx_conn.Open();
List<string[]> parameters = new List<string[]>();
string[] params_array = additional_parameters.Split(new char[] {',', ';'});
foreach (string p in params_array)
{
if (p != "")
{
string[] name_and_column = p.Trim().Split(' ');
parameters.Add(name_and_column);
}
}
DataTable dt = new DataTable();
dt.Columns.Add(new DataColumn(data_column_name,
Type.GetType("System.String")));
foreach (string[] p in parameters)
dt.Columns.Add(new DataColumn(p[1], Type.GetType("System.String")));
using (BingoSession session = new BingoSession())
{
BingoCore.lib.bingoProfilingReset(true);
BingoTimer timer = new BingoTimer("total");
SqlConnection ext_conn = null;
try
{
string conn_string = String.Format(
"server={0};integrated security=true;database={1};enlist=false",
getServername(ctx_conn), ctx_conn.Database);
ext_conn = new SqlConnection(conn_string);
ext_conn.Open();
int imported_count = 0;
bool has_data = false;
do
{
DataRow new_row = dt.NewRow();
has_data = populateRowFunc(new_row, parameters);
if (has_data)
{
dt.Rows.Add(new_row);
imported_count++;
}
if (dt.Rows.Count >= 10000 || !has_data)
{
// Flush data table via SqlBulkCopy
BingoTimer timer_sql = new BingoTimer("import.sql_bulk_copy");
using (SqlTransaction transaction =
ext_conn.BeginTransaction())
{
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(ext_conn,
SqlBulkCopyOptions.FireTriggers, transaction))
{
bulkCopy.DestinationTableName = table_name;
bulkCopy.ColumnMappings.Add(data_column_name, data_column_name);
foreach (string[] p in parameters)
bulkCopy.ColumnMappings.Add(p[1], p[1]);
bulkCopy.BatchSize = dt.Rows.Count;
bulkCopy.BulkCopyTimeout = 3600;
bulkCopy.WriteToServer(dt);
}
transaction.Commit();
}
timer_sql.end();
BingoCore.lib.bingoProfIncCounter("import.sql_bulk_copy_size", dt.Rows.Count);
dt.Rows.Clear();
BingoLog.logMessage(" {0} molecules imported", imported_count);
BingoLog.logMessage("Intermediate statistics for import into table {0}:\n{1}\n",
table_name, BingoCore.bingoProfilingGetStatistics(true));
BingoCore.lib.bingoProfilingReset(false);
}
} while (has_data);
BingoLog.logMessage(" Done.");
timer.end();
BingoLog.logMessage("Statistics for import into table {0}:\n{1}\n",
table_name, BingoCore.bingoProfilingGetStatistics(true));
}
catch (Exception ex)
{
BingoLog.logMessage("Exception {0} in {1}:\n{2}", ex.Message, ex.Source, ex.StackTrace);
throw;
}
finally
{
if (ext_conn != null)
ext_conn.Close();
// Close import
BingoCore.lib.bingoSDFImportClose();
BingoCore.lib.bingoRDFImportClose();
BingoCore.lib.bingoSMILESImportClose();
}
}
}
}
public static long ProfilingGetCount (SqlString counter_name,
SqlBoolean whole_session, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
return BingoCore.lib.bingoProfilingGetCount(counter_name.Value,
whole_session.Value);
}
}
public static SqlBinary CompactMolecule(SqlBinary molecule, SqlBoolean save_xyz, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
ContextFlags flags = ContextFlags.X_PSEUDO | ContextFlags.IGNORE_CBDM;
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, flags);
}
return BingoCore.mangoICM(molecule.Value, save_xyz.Value);
}
}
public static void _CheckMemoryAllocate(SqlInt32 dotnet_size_mb, SqlInt32 block_size_mb,
SqlInt32 core_size_mb, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
long block_size = block_size_mb.Value;
BingoLog.logMessage("Allocating {0} Mb in .NET by {1}Mb blocks...",
dotnet_size_mb.Value, block_size);
int sum = 0;
List<object> mem_blocks = new List<object>();
long mem_left = dotnet_size_mb.Value;
int index = 0;
while (mem_left != 0)
{
long cur_alloc;
if (mem_left > block_size)
cur_alloc = block_size;
else
cur_alloc = mem_left;
byte[] data = new byte[cur_alloc * 1024 * 1024];
foreach (byte b in data)
sum += b;
mem_blocks.Add(data);
index++;
mem_left -= cur_alloc;
BingoLog.logMessage(" block {0} allocated, {1}Mb is left to allocate...",
index, mem_left);
}
BingoLog.logMessage("Check sum is {0}", sum);
BingoLog.logMessage("Allocating {0} Mb in bingo-core...", core_size_mb.Value);
int ret = BingoCore.lib.bingoCheckMemoryAllocate(core_size_mb.Value * 1024 * 1024);
if (ret != 1)
{
BingoLog.logMessage(" Failed: {0}", BingoCore.lib.bingoGetError());
throw new Exception("Failed. See Bingo log for details");
}
BingoLog.logMessage(" OK");
BingoLog.logMessage(" Waiting 2 sec...");
Thread.Sleep(2000);
BingoCore.lib.bingoCheckMemoryFree();
BingoLog.logMessage(" Done.");
SqlContext.Pipe.Send("Done.");
}
}
private static IEnumerable CheckChemicalTable (SqlString table, SqlString id_column,
SqlString data_column, SqlString bingo_schema, bool is_reaction)
{
BingoLog.logMessage("Checking chemical table {0}", table.Value);
using (BingoSession session = new BingoSession())
{
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0,
ContextFlags.NTHREADS | ContextFlags.FINGERPRINTS);
BingoIndexID id = new BingoIndexID(conn, table.Value);
BingoIndexData dummy_data;
if (is_reaction)
dummy_data = new RingoIndexData(id, id_column.Value, data_column.Value, bingo_schema.Value);
else
dummy_data = new MangoIndexData(id, id_column.Value, data_column.Value, bingo_schema.Value);
ArrayList errors = new ArrayList();
bingoOperationDelegate check_insert_op =
getInsertRecordsDelegate(table.Value, false, false, false, errors);
if (BingoCore.lib.bingoIndexBegin() != 1)
throw new Exception(BingoCore.lib.bingoGetError());
BingoCore.lib.bingoIndexSetSkipFP(true);
check_insert_op(conn, conn, dummy_data);
BingoCore.lib.bingoIndexEnd();
return errors;
}
}
}
public static SqlString Name(SqlBinary molecule, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
return BingoCore.bingoGetNameCore(molecule.Value);
}
}
public static SqlString InChI(SqlBinary molecule, SqlString options, SqlString bingo_schema)
{
using (BingoSession session = new BingoSession())
{
ContextFlags flags = ContextFlags.X_PSEUDO | ContextFlags.IGNORE_CBDM;
using (SqlConnection conn = new SqlConnection("context connection=true"))
{
conn.Open();
prepareContext(conn, bingo_schema.Value, 0, flags);
}
return BingoCore.mangoInChI(molecule.Value, options.Value);
}
}
