object IInvokeServiceOps.InvokeServiceOperation(int opCode, object[] args)
{
MobiusAnnotationService op = (MobiusAnnotationService)opCode;
switch (op)
{
case MobiusAnnotationService.CreateInstance:
{
int instanceId = -1;
Mobius.UAL.AnnotationDao instance = new Mobius.UAL.AnnotationDao();
lock (_lockObject)
{
instanceId = _nextInstanceId++;
_instanceIdToInstance.Add(instanceId, instance);
}
return(instanceId);
}
case MobiusAnnotationService.DisposeInstance:
{
bool disposed = false;
int instanceId = (int)args[0];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
_instanceIdToInstance.Remove(instanceId);
}
}
if (instance != null)
{
instance.Dispose();
disposed = true;
}
return(disposed);
}
case MobiusAnnotationService.Select:
{
int instanceId = (int)args[0];
int mthdVrsnId = (int)args[1];
string cmpndId = (string)args[2];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
List <Mobius.Data.AnnotationVo> mobiusAnnotationVos =
instance.Select(mthdVrsnId, cmpndId);
List <AnnotationVo> annotationVos =
_transHelper.Convert <List <Mobius.Data.AnnotationVo>, List <AnnotationVo> >(mobiusAnnotationVos);
return(annotationVos);
}
return(null);
}
case MobiusAnnotationService.SelectByResultId:
{
int instanceId = (int)args[0];
long rsltId = (long)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
Mobius.Data.AnnotationVo mobiusAnnotationVo =
instance.Select(rsltId);
AnnotationVo annotationVo =
_transHelper.Convert <Mobius.Data.AnnotationVo, AnnotationVo>(mobiusAnnotationVo);
return(annotationVo);
}
return(null);
}
case MobiusAnnotationService.SelectCompoundCount:
{
int instanceId = (int)args[0];
int mthdVrsnId = (int)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int count = instance.SelectCompoundCount(mthdVrsnId);
return(count);
}
return(null);
}
case MobiusAnnotationService.SelectRowCount:
{
int instanceId = (int)args[0];
int mthdVrsnId = (int)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int rowCount = instance.SelectRowCount(mthdVrsnId);
return(rowCount);
}
return(null);
}
case MobiusAnnotationService.GetNonNullRsltCnt:
{
int instanceId = (int)args[0];
int mthdVrsnId = (int)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int rowCount = instance.GetNonNullRsltCnt(mthdVrsnId);
return(rowCount);
}
return(null);
}
case MobiusAnnotationService.GetNextIdsLong:
{
int instanceId = (int)args[0];
int seqQueueRequestSize = (int)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
//work-around for .Net bug for writes of multiples of 128
// (See: http://social.msdn.microsoft.com/Forums/en/wcf/thread/0c71eedb-6c71-4b94-97c7-332195a7eb5c )
if (seqQueueRequestSize % 2 == 0)
{
seqQueueRequestSize++;
}
long[] nextIds =
instance.GetNextIdsLong(seqQueueRequestSize);
return(nextIds);
}
return(null);
}
case MobiusAnnotationService.SetArchiveStatus:
{
int instanceId = (int)args[0];
long rsltId = (long)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int result =
instance.SetArchiveStatus(rsltId);
return(result);
}
return(null);
}
case MobiusAnnotationService.SetResultGroupArchiveStatus:
{
int instanceId = (int)args[0];
long rsltGrpId = (long)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int result =
instance.SetResultGroupArchiveStatus(rsltGrpId);
return(result);
}
return(null);
}
case MobiusAnnotationService.DeleteCompound:
{
int instanceId = (int)args[0];
int mthdVrsnId = (int)args[1];
string cmpndId = (string)args[2];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int result =
instance.DeleteCompound(mthdVrsnId, cmpndId);
return(result);
}
return(null);
}
case MobiusAnnotationService.DeleteTable:
{
int instanceId = (int)args[0];
int mthdVrsnId = (int)args[1];
bool useTransactions = (bool)args[2];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int result =
instance.DeleteTable(mthdVrsnId, useTransactions);
return(result);
}
return(null);
}
case MobiusAnnotationService.DeleteResultGroup:
{
int instanceId = (int)args[0];
long rsltGrpId = (long)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int result =
instance.DeleteResultGroup(rsltGrpId);
return(result);
}
return(null);
}
case MobiusAnnotationService.Insert:
{
int instanceId = (int)args[0];
List <AnnotationVo> voList = (List <AnnotationVo>)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
List <Mobius.Data.AnnotationVo> mobiusAnnotationVos =
_transHelper.Convert <List <AnnotationVo>, List <Mobius.Data.AnnotationVo> >(voList);
bool result =
instance.Insert(mobiusAnnotationVos);
return(result);
}
return(null);
}
case MobiusAnnotationService.InsertUpdateRow:
{
int instanceId = (int)args[0];
List <AnnotationVo> voList = (List <AnnotationVo>)args[1];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
List <Mobius.Data.AnnotationVo> mobiusAnnotationVos =
_transHelper.Convert <List <AnnotationVo>, List <Mobius.Data.AnnotationVo> >(voList);
long newRsltId = instance.InsertUpdateRow(mobiusAnnotationVos[0]);
return(newRsltId);
}
else
{
return(null);
}
}
case MobiusAnnotationService.InsertUpdateRowAndUserObjectHeader:
{
List <AnnotationVo> voList = (List <AnnotationVo>)args[0];
List <Mobius.Data.AnnotationVo> mobiusAnnotationVos =
_transHelper.Convert <List <AnnotationVo>, List <Mobius.Data.AnnotationVo> >(voList);
long newRsltId = Mobius.UAL.AnnotationDao.InsertUpdateRowAndUserObjectHeader(mobiusAnnotationVos[0]);
return(newRsltId);
}
case MobiusAnnotationService.DeepClone:
{
UserObjectNode uoNode = (UserObjectNode)args[0];
Mobius.Data.UserObject mobiusUO = _transHelper.Convert <UserObjectNode, Mobius.Data.UserObject>(uoNode);
Mobius.Data.UserObject fullMobiusUO = Mobius.UAL.AnnotationDao.DeepClone(mobiusUO);
UserObjectNode fullUONode = _transHelper.Convert <Mobius.Data.UserObject, UserObjectNode>(fullMobiusUO);
return(fullUONode);
}
case MobiusAnnotationService.UpdateCid:
{
int instanceId = (int)args[0];
int mthdVrsnId = (int)args[1];
string oldCid = (string)args[2];
string newCid = (string)args[3];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int result =
instance.UpdateCid(mthdVrsnId, oldCid, newCid);
return(result);
}
return(null);
}
case MobiusAnnotationService.UpdateResultGroupCid:
{
int instanceId = (int)args[0];
long rsltGrpId = (long)args[1];
string oldCid = (string)args[2];
string newCid = (string)args[3];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
int result =
instance.UpdateResultGroupCid(rsltGrpId, oldCid, newCid);
return(result);
}
return(null);
}
case MobiusAnnotationService.BeginTransaction:
{
int instanceId = (int)args[0];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
instance.BeginTransaction();
return(true);
}
return(false);
}
case MobiusAnnotationService.Commit:
{
int instanceId = (int)args[0];
Mobius.UAL.AnnotationDao instance = null;
lock (_lockObject)
{
if (_instanceIdToInstance.ContainsKey(instanceId))
{
instance = _instanceIdToInstance[instanceId];
}
}
if (instance != null)
{
instance.Commit();
return(true);
}
return(false);
}
}
return(null);
}
object IInvokeServiceOps.InvokeServiceOperation(int opCode, object[] args)
{
Mobius.Data.UserObject uo;
byte[] sUo;
MobiusCidListService op = (MobiusCidListService)opCode;
switch (op)
{
case MobiusCidListService.Read:
{
int listId = (int)args[0];
string mtName = (string)args[1];
Mobius.Data.MetaTable mt = (mtName == null) ? null : Mobius.Data.MetaTableCollection.Get(mtName);
Data.CidList mobiusCidList = UAL.CidListDao.Read(listId, mt);
if (mobiusCidList == null)
{
return(null);
}
uo = mobiusCidList.UserObject;
uo.Content = mobiusCidList.ToMultilineString();
sUo = uo.SerializeBinary();
return(sUo);
}
case MobiusCidListService.ExecuteListLogic:
{
string list1Name = (string)args[0];
string list2Name = (string)args[1];
Data.ListLogicType listLogicType = (Data.ListLogicType)args[2];
int result =
UAL.CidListDao.ExecuteListLogic(list1Name, list2Name, listLogicType);
return(result);
}
case MobiusCidListService.CopyList:
{
string sourceUOInternalName = (string)args[0];
UserObjectNode targetUONode = (UserObjectNode)args[1];
Data.UserObject targetUO = _transHelper.Convert <UserObjectNode, Data.UserObject>(targetUONode);
UAL.CidListDao.CopyList(sourceUOInternalName, targetUO);
targetUONode = _transHelper.Convert <Data.UserObject, UserObjectNode>(targetUO);
return(targetUONode);
}
case MobiusCidListService.ReadLibrary:
{
int libId = (int)args[0];
Data.CidList mobiusCidList = UAL.CidListDao.ReadLibrary(libId);
if (mobiusCidList == null)
{
return(null);
}
uo = mobiusCidList.UserObject;
uo.Content = mobiusCidList.ToMultilineString();
sUo = uo.SerializeBinary();
return(sUo);
}
}
return(null);
}
object IInvokeServiceOps.InvokeServiceOperation(int opCode, object[] args)
{
MobiusQueryEngineService op = (MobiusQueryEngineService)opCode;
switch (op)
{
case MobiusQueryEngineService.Initialize:
{
Qel.QueryEngine.InitializeForSession();
return(null);
}
case MobiusQueryEngineService.CreateInstance:
{
Qel.QueryEngine instance = new Mobius.QueryEngineLibrary.QueryEngine();
return(instance.Id);
}
case MobiusQueryEngineService.DisposeInstance:
{
int instanceId = (int)args[0];
bool disposed = Qel.QueryEngine.Dispose(instanceId);
return(disposed);
}
case MobiusQueryEngineService.SetParameter:
{
string parm = "", value = "";
if (args.Length == 2)
{
parm = args[0].ToString();
value = args[1].ToString();
}
else // old form (remove when all old clients are updated)
{
parm = "DatabaseSubset";
value = args[0].ToString();
}
Qel.QueryEngine.SetParameter(parm, value);
return(null);
}
case MobiusQueryEngineService.GetSummarizationDetailQuery:
{
int instanceId = (int)args[0];
string metaTableName = (string)args[1];
string metaColumnName = (string)args[2];
int level = (int)args[3];
string resultId = (string)args[4];
//Qel.QueryEngine qe = null;
//lock (Qel.QueryEngine.IdToInstanceDict)
//{
// if (Qel.QueryEngine.IdToInstanceDict.ContainsKey(instanceId))
// {
// qe = Qel.QueryEngine.IdToInstanceDict[instanceId];
// }
//}
//if (qe != null)
//{
string queryXml = "";
Data.Query query = QueryEngine.GetSummarizationDetailQuery(metaTableName, metaColumnName, level, resultId);
if (query != null)
{
queryXml = query.Serialize(false);
}
return(queryXml);
//}
//else
//{
// throw new ArgumentException("Not a valid query engine instance id!");
//}
}
case MobiusQueryEngineService.GetDrilldownDetailQuery:
{
int instanceId = (int)args[0];
string metaTableName = (string)args[1];
string metaColumnName = (string)args[2];
int level = (int)args[3];
string resultId = (string)args[4];
//Qel.QueryEngine qe = null;
//lock (Qel.QueryEngine.IdToInstanceDict)
//{
// if (Qel.QueryEngine.IdToInstanceDict.ContainsKey(instanceId))
// {
// qe = Qel.QueryEngine.IdToInstanceDict[instanceId];
// }
//}
//if (qe != null)
//{
Mobius.Data.MetaTable metaTable = Mobius.Data.MetaTableCollection.GetExisting(metaTableName);
Mobius.Data.MetaColumn metaColumn = metaTable.GetMetaColumnByName(metaColumnName);
Data.Query query = QueryEngine.GetDrilldownDetailQuery(metaTable, metaColumn, level, resultId);
string queryXml = query.Serialize(false);
return(queryXml);
//}
//else
//{
// throw new ArgumentException("Not a valid query engine instance id!");
//}
}
case MobiusQueryEngineService.GetImage:
{
string mtMcName = null;
int instanceId = (int)args[0];
if (args[1] is string) // New "mtName.mcName" format for arg (Post Client 5.0)
{
mtMcName = (string)args[1];
}
else if (args[1] is MetaColumn) // old Mobius.Services.Types.MetaColumn format
{
MetaColumn mc = (MetaColumn)args[1];
mtMcName = mc.MetaTable.Name + "." + mc.Name;
}
else
{
return(null); // error
}
Mobius.Data.MetaColumn mobiusMC = Mobius.Data.MetaColumn.ParseMetaTableMetaColumnName(mtMcName);
string graphicsIdString = (string)args[2];
int desiredWidth = (int)args[3];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
//Mobius.Data.MetaColumn mobiusMC = _transHelper.Convert<MetaColumn, Mobius.Data.MetaColumn>(metaColumn);
System.Drawing.Bitmap bitmap = qe.GetImage(mobiusMC, graphicsIdString, desiredWidth);
Types.Bitmap result = new Types.Bitmap(bitmap);
return(result);
}
case MobiusQueryEngineService.ResolveCidListReference:
{
string tok = (string)args[0];
Mobius.Data.UserObject uo = Qel.QueryEngine.ResolveCidListReference(tok);
UserObjectNode result = _transHelper.Convert <Mobius.Data.UserObject, UserObjectNode>(uo);
return(result);
}
case MobiusQueryEngineService.GetRootTable:
{
string queryString = (string)args[0];
Mobius.Data.Query mobiusQuery = Data.Query.Deserialize(queryString);
Mobius.Data.MetaTable mobiusMT = Qel.QueryEngine.GetRootTable(mobiusQuery);
string mtString = null;
if (mobiusMT != null)
{
mtString = mobiusMT.Serialize();
}
return(mtString);
}
case MobiusQueryEngineService.DoPresearchChecksAndTransforms:
{
string serializedQuery = (string)args[0];
Data.Query q = Data.Query.Deserialize(serializedQuery);
q = Qel.QueryEngine.DoPreSearchTransformations(q);
if (q == null)
{
return(null);
}
string serializedQuery2 = q.Serialize(true);
return(serializedQuery2);
}
case MobiusQueryEngineService.GetKeys:
{
int instanceId = (int)args[0];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
List <string> keys = qe.GetKeys();
return(keys);
}
case MobiusQueryEngineService.ExecuteQuery:
{
int instanceId = (int)args[0];
string serializedQuery = (string)args[1];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
Data.Query q = Data.Query.Deserialize(serializedQuery);
List <string> result = qe.ExecuteQuery(q, false, false);
return(result);
}
case MobiusQueryEngineService.TransformAndExecuteQuery:
{
int instanceId = (int)args[0];
string serializedQuery = (string)args[1];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
Data.Query q2;
Data.Query q = Data.Query.Deserialize(serializedQuery);
List <string> keyList = qe.TransformAndExecuteQuery(q, out q2);
object[] sa = new object[2];
sa[0] = keyList;
if (q2 != null) // any transformed query?
{
sa[1] = q2.Serialize(true, true); // serialize including metatables not previously send to client
}
return(sa);
}
case MobiusQueryEngineService.BuildSqlStatements:
{
int instanceId = (int)args[0];
string serializedQuery = (string)args[1];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
Data.Query q = Data.Query.Deserialize(serializedQuery);
string sqlStatements = qe.BuildSqlStatements(q);
return(sqlStatements);
}
case MobiusQueryEngineService.SaveSpotfireSql:
{
string sqlStmtName = (string)args[0];
string serializedQuery = (string)args[1];
Data.Query q = Data.Query.Deserialize(serializedQuery);
int stmtId = Mobius.QueryEngineLibrary.QueryEngine.SaveSpotfireSql(sqlStmtName, q);
return(stmtId);
}
case MobiusQueryEngineService.SaveSpotfireKeyList:
{
string keyColName, listType, keyList;
if (args.Length >= 3)
{
keyColName = (string)args[0];
listType = (string)args[1];
keyList = (string)args[2];
}
else if (args.Length == 2) // old form
{
keyColName = "CORP_ID";
listType = (string)args[0];
keyList = (string)args[1];
}
else // old form for cid list
{
keyColName = "CORP_ID";
listType = "CIDLIST";
keyList = (string)args[0];
}
string keyListName = Mobius.QueryEngineLibrary.QueryEngine.SaveSpotfireKeyList(keyColName, listType, keyList);
return(keyListName);
}
case MobiusQueryEngineService.ReadSpotfireSql:
{
string sqlStmtName = args[0] as string;
int version = (int)args[1];
string sql = Mobius.QueryEngineLibrary.QueryEngine.ReadSpotfireSql(sqlStmtName, version);
return(sql);
}
case MobiusQueryEngineService.RemapTablesForRetrieval: // DoPreRetrievalTransformation
{
int instanceId = (int)args[0];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
Mobius.Data.Query q = qe.DoPreRetrievalTableExpansions();
if (q == null)
{
return(null);
}
string serializedQuery = q.Serialize(true); // serialize including metatables not previously included
return(serializedQuery);
}
case MobiusQueryEngineService.NextRowsSerialized:
{
int minRows = 1;
bool returnQeStats = false;
List <Mobius.Data.MetaBrokerStats> mbStats = null;
int instanceId = (int)args[0];
int ai = 1;
if (args.Length >= 4) // newer version with minRows arg
{
minRows = (int)args[ai++];
}
int maxRows = (int)args[ai++];
int maxTime = (int)args[ai++];
if (ai < args.Length) // newer version with returnQeStats arg
{
returnQeStats = (bool)args[ai++];
}
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
if (returnQeStats)
{
mbStats = new List <Mobius.Data.MetaBrokerStats>();
}
byte[] serializedRows = qe.NextRowsSerialized(minRows, maxRows, maxTime, mbStats);
if (!returnQeStats)
{
return(serializedRows);
}
else // return serialized rows and stats in a two-element object array
{
object[] oa = new object[2];
oa[0] = serializedRows;
oa[1] = Mobius.Data.MetaBrokerStats.SerializeList(mbStats);
return(oa);
}
}
case MobiusQueryEngineService.NextRows:
{
int minRows = 1;
int instanceId = (int)args[0];
int ai = 1;
if (args.Length >= 4) // newer version with minRows arg
{
minRows = (int)args[ai++];
}
int maxRows = (int)args[ai++];
int maxTime = (int)args[ai++];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
List <object[]> rows = qe.NextRows(minRows, maxRows, maxTime);
DataRow dataRow = null;
List <DataRow> dataRows = new List <DataRow>();
if (rows == null)
{
return(dataRows);
}
for (int ri = 0; ri < rows.Count; ri++) // convert each row
{
object[] row = rows[ri];
if (row != null)
{
dataRow = new DataRow();
object[] convertedRow = new object[row.Length];
for (int i = 0; i < row.Length; i++)
{
convertedRow[i] = _transHelper.ConvertObject(row[i]);
}
dataRow.Data = convertedRow;
}
dataRows.Add(dataRow);
}
return(dataRows);
}
case MobiusQueryEngineService.NextRow:
{
int instanceId = (int)args[0];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
object[] row = qe.NextRow();
DataRow dataRow = null;
if (row != null)
{
dataRow = new DataRow();
object[] convertedRow = new object[row.Length];
for (int i = 0; i < row.Length; i++)
{
convertedRow[i] = _transHelper.ConvertObject(row[i]);
}
dataRow.Data = convertedRow;
}
return(dataRow);
}
case MobiusQueryEngineService.Close:
{
int instanceId = (int)args[0];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
qe.Close();
return(true);
}
case MobiusQueryEngineService.Cancel:
{
int instanceId = (int)args[0];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
qe.Cancel(false);
return(true);
}
case MobiusQueryEngineService.GetQueryEngineState:
{
int instanceId = (int)args[0];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
Mobius.Data.QueryEngineState state = qe.State;
QueryEngineState result = _transHelper.Convert <Mobius.Data.QueryEngineState, QueryEngineState>(state);
return(result);
}
case MobiusQueryEngineService.LogExceptionAndSerializedQuery:
{
string exMsg = (string)args[0];
string serializedQuery = (string)args[1];
Data.Query query = Data.Query.Deserialize(serializedQuery);
return(Qel.QueryEngine.LogExceptionAndSerializedQuery(exMsg, query));
}
case MobiusQueryEngineService.LogQueryExecutionStatistics:
{
Qel.QueryEngine.LogQueryExecutionStatistics();
return(null);
}
case MobiusQueryEngineService.ValidateCalculatedFieldExpression:
{
string advExpr = (string)args[0];
return(Qel.QueryEngine.ValidateCalculatedFieldExpression(advExpr));
}
case MobiusQueryEngineService.CreateQueryFromMQL:
{
string mql = (string)args[0];
Mobius.Data.Query mobiusQuery = Mobius.Data.MqlUtil.ConvertMqlToQuery(mql);
Query result = _transHelper.Convert <Mobius.Data.Query, Query>(mobiusQuery); //translate the result
return(result);
}
case MobiusQueryEngineService.ExecuteMQLQuery:
{
Mobius.Data.Query q2;
int instanceId = (int)args[0];
string mql = (string)args[1];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
Mobius.Data.Query q = Mobius.Data.MqlUtil.ConvertMqlToQuery(mql);
List <string> result = qe.TransformAndExecuteQuery(q, out q2);
return(result);
}
case MobiusQueryEngineService.GetSelectAllDataQuery:
{
string mtName = (string)args[0];
string cn = (string)args[1];
string queryXml = "";
Mobius.Data.Query q = QueryEngineLibrary.QueryEngine.GetSelectAllDataQuery(mtName, cn);
if (q != null)
{
queryXml = q.Serialize(false);
}
return(queryXml);
}
case MobiusQueryEngineService.GetStandardMobileQueries:
{
Data.Query[] mobileQueries = QueryEngineLibrary.QueryEngine.GetStandardMobileQueries();
List <Query> queries = new List <Query>();
foreach (Data.Query query in mobileQueries)
{
Query typesQuery = _transHelper.Convert <Mobius.Data.Query, Query>(query);
queries.Add(typesQuery);
}
return(queries.ToArray());
}
case MobiusQueryEngineService.GetMobileQueriesByOwner:
{
string user = (string)args[0];
Data.Query[] mobileQueries = QueryEngineLibrary.QueryEngine.GetMobileQueriesByOwner(user);
List <Query> queries = new List <Query>();
foreach (Data.Query query in mobileQueries)
{
Query typesQuery = _transHelper.Convert <Mobius.Data.Query, Query>(query);
queries.Add(typesQuery);
}
return(queries.ToArray());
}
case MobiusQueryEngineService.GetAdditionalData:
{
int instanceId = (int)args[0];
string command = (string)args[1];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
object o = qe.GetAdditionalData(command);
return(o);
}
case MobiusQueryEngineService.ExportDataToSpotfireFiles:
{
int instanceId = (int)args[0];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
ExportParms ep = ExportParms.Deserialize(args[1] as string);
QueryEngineStats qeStats = qe.ExportDataToSpotfireFiles(ep);
return(qeStats != null ? qeStats.Serialize() : null);
}
case MobiusQueryEngineService.CompleteRowRetrieval:
{
int instanceId = (int)args[0];
Qel.QueryEngine qe = GetQueryEngineInstance(instanceId);
QueryEngineStats qeStats = qe.CompleteRowRetrieval();
return(qeStats != null ? qeStats.Serialize() : null);
}
default:
throw new InvalidOperationException("Unrecognized operation: " + (int)op);
}
}
