private void MaintainCountofFiveForQueries(OMQuery query, ConnectionDetails connection)
{
List <OMQuery> qListForClass = FetchQueriesForAClass(query.BaseClass);
if (qListForClass != null)
{
bool check = false;
if (qListForClass.Any(qry => qry.QueryString == query.QueryString))
{
check = true;
OMQuery result = connection.QueryList.Find(bk => bk.QueryString == query.QueryString);
connection.QueryList.Remove(result);
DeleteQuery(result);
}
if (qListForClass.Count >= 5)
{
if (!check)
{
OMQuery q = qListForClass[qListForClass.Count - 1];
OMQuery result = connection.QueryList.Find(bk => bk.QueryString == q.QueryString);
connection.QueryList.Remove(result);
DeleteQuery(result);
}
}
}
}
internal void AddQueryToList(OMQuery query)
{
try
{
long id = ChkIfRecentConnIsInDb();
if (id > 0)
{
ConnectionDetails temprc = Db4oClient.OMNConnection.Ext().GetByID(id) as ConnectionDetails;
Db4oClient.OMNConnection.Ext().Activate(temprc, 5);
MaintainCountofTwentyforQueries(temprc);
MaintainCountofFiveForQueries(query, temprc);
if (temprc != null)
{
temprc.Timestamp = DateTime.Now;
temprc.QueryList.Add(query);
}
Db4oClient.OMNConnection.Ext().Store(temprc, 5);
Db4oClient.OMNConnection.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
finally
{
Db4oClient.CloseRecentConnectionFile();
}
}
public static long[] ExecuteQuery(OMQuery query)
{
QueryParser qParser = new QueryParser(query);
IObjectSet objSet = qParser.ExecuteOMQueryList();
return objSet != null ? objSet.Ext().GetIDs() : null;
}
public static long[] ExecuteQuery(OMQuery query)
{
QueryParser qParser = new QueryParser(query);
IObjectSet objSet = qParser.ExecuteOMQueryList();
return objSet != null ? objSet.Ext().GetIDs() : null;
}
private void LoadData()
{
masterView.Rows.Clear();
detailsTabs.Items.Clear();
detailsTabs.SelectedItem = null;
Hashtable hAttributes = new Hashtable();
try
{
omQuery = (OMQuery) Helper.OMResultedQuery[ClassName];
if (omQuery != null)
{
hAttributes = omQuery.AttributeList;
}
PagingData pagingData = new PagingData(m_pagingStartIndex);
if (objectid != null)
{
lstObjIdLong = new List<long>(objectid);
pagingData.ObjectId = lstObjIdLong;
const int pageNumber = m_pagingStartIndex + 1;
lblPageCount.Text = pagingData.GetPageCount().ToString();
txtCurrentPage.Text = pageNumber.ToString();
labelNoOfObjects.Text = pagingData.ObjectId.Count.ToString();
if (lstObjIdLong.Count > 0)
{
List<Hashtable> hashListResult = AssemblyInspectorObject.DataPopulation.ReturnQueryResults(pagingData, true,
omQuery.BaseClass,
omQuery.
AttributeList);
masterView.SetDataGridColumnHeader(hashListResult, ClassName, omQuery.AttributeList);
masterView.SetDatagridRows(hashListResult, ClassName, hAttributes, 1);
ListofModifiedObjects.AddDatagrid(ClassName, masterView);
}
if (pagingData.ObjectId.Count <= PagingData.PAGE_SIZE)
{
btnPrevious.Enabled = false;
btnFirst.Enabled = false;
btnNext.Enabled = false;
btnLast.Enabled = false;
}
else
{
btnPrevious.Enabled = false;
btnFirst.Enabled = false;
btnNext.Enabled = true;
btnLast.Enabled = true;
}
}
ApplyReadonlyCondition(OMEInteraction.GetCurrentConnParams().ConnectionReadOnly);
}
catch (Exception oEx)
{
LoggingHelper.ShowMessage(oEx);
}
}
private static void DeleteQuery(OMQuery query)
{
List <OMQuery> queries = (from OMQuery q in Db4oClient.OMNConnection where q.QueryString == query.QueryString select q).ToList();
if (queries.Count <= 0)
{
return;
}
Db4oClient.OMNConnection.Delete(queries[0]);
Db4oClient.OMNConnection.Commit();
}
private void SaveIndex()
{
try
{
SaveIndexClass saveIndexInstance = new SaveIndexClass(Helper.ClassName);
foreach (DataGridViewRow row in dbGridViewProperties.Rows)
{
bool boolValue = Convert.ToBoolean(row.Cells[2].Value);
saveIndexInstance.Fieldname.Add(row.Cells[0].Value.ToString());
saveIndexInstance.Indexed.Add(boolValue);
}
CloseQueryResultToolWindows();
ConnParams conparam = dbInteraction.GetCurrentRecentConnection().ConnParam;
dbInteraction.CloseCurrDb();
saveIndexInstance.SaveIndex();
RecentQueries currRecentConnection = new RecentQueries(conparam);
Db4oClient.conn = conparam;
RecentQueries tempRc = currRecentConnection.ChkIfRecentConnIsInDb();
if (tempRc != null)
currRecentConnection = tempRc;
currRecentConnection.Timestamp = DateTime.Now;
dbInteraction.ConnectoToDB(currRecentConnection);
dbInteraction.SetCurrentRecentConnection(currRecentConnection);
//Only if following line is added the index is saved.
OMQuery omQuery = new OMQuery(saveIndexInstance.Classname , DateTime.Now);
long[] objectid = dbInteraction.ExecuteQueryResults(omQuery);
if (ObjectBrowser.Instance.ToolStripButtonAssemblyView.Checked)
ObjectBrowser.Instance.DbtreeviewObject.FindNSelectNode(ObjectBrowser.Instance.DbAssemblyTreeView.Nodes[0], saveIndexInstance.Classname, ObjectBrowser.Instance.DbAssemblyTreeView);
else
ObjectBrowser.Instance.DbtreeviewObject.FindNSelectNode(ObjectBrowser.Instance.DbtreeviewObject.Nodes[0], saveIndexInstance.Classname, ObjectBrowser.Instance.DbtreeviewObject);
tabStripProperties.SelectedItem = tabItemClassProperties;
MessageBox.Show("Index Saved Successfully!", Helper.GetResourceString(Constants.PRODUCT_CAPTION), MessageBoxButtons.OK);
}
catch (Exception oEx)
{
LoggingHelper.ShowMessage(oEx);
}
}
private void MaintainCountofTwentyforQueries(ConnectionDetails connection)
{
List <OMQuery> qList = FetchAllQueries();
if (qList.Count < 20)
{
return;
}
OMQuery q = qList[qList.Count - 1];
qList.RemoveAt(qList.Count - 1);
foreach (OMQuery qry1 in connection.QueryList.Where(qry1 => q.QueryString.Equals(qry1.QueryString)))
{
connection.QueryList.Remove(qry1);
DeleteQuery(qry1);
break;
}
}
public void deleteRecentQueriesForAConnection()
{
List <OMQuery> qList = new List <OMQuery>();
IObjectSet objSet = null;
try
{
container = Db4oClient.RecentConn;
IQuery query = container.Query();
query.Constrain(typeof(RecentQueries));
query.Descend("m_connParam").Descend("m_connection").Constrain(m_connParam.Connection);
objSet = query.Execute();
if (objSet != null)
{
RecentQueries recQueries = (RecentQueries)objSet.Next();
for (int i = 0; i < recQueries.QueryList.Count; i++)
{
OMQuery q = recQueries.m_queryList[0];
if (q != null)
{
// m_queryList.Remove(q);
container.Delete(q);
}
}
recQueries.m_queryList.Clear();
recQueries.m_TimeOfCreation = Sharpen.Runtime.CurrentTimeMillis();
container.Ext().Store(recQueries, 5);
container.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public long[] ExecuteQueryResults(OMQuery omQuery)
{
return(RunQuery.ExecuteQuery(omQuery));
}
public static List<Hashtable> ExecuteQueryResults(OMQuery omQuery, PagingData pgData, bool refresh, Hashtable attributeList)
{
RunQuery.ExecuteQuery(omQuery);
return ReturnQueryResults(pgData, refresh, omQuery.BaseClass, attributeList);
}
/// <summary>
/// Set the query to current connection
/// </summary>
/// <param name="query"></param>
private static void AddQueryToCurrentConnection(OMQuery query)
{
try
{
if (!string.IsNullOrEmpty(query.QueryString))
OMEInteraction.AddQueriesToList(query);
}
catch (Exception oEx)
{
LoggingHelper.ShowMessage(oEx);
}
}
/// <summary>
/// Poulates Query in Query Result pane/recent query selected
/// </summary>
/// <param name="omQry"></param>
public void PopulateQueryBuilderGroup(OMQuery omQry)
{
List<OMQueryGroup> listOMQueryGroup;
Hashtable listQueryAttributes;
OMQueryGroup omGroup;
DataGridViewGroup group;
OMQuery omQuery;
try
{
OMETrace.WriteFunctionStart();
//Set the omQuery
if (omQry != null)
{
omQuery = omQry;
//query is not available then dont do anything
if (omQuery == null)
return;
listOMQueryGroup = omQuery.ListQueryGroup;
Helper.HashTableBaseClass.Clear();
Helper.BaseClass = Helper.ClassName = omQuery.BaseClass;
//Only Add when recent query is populated
if (omQuery.ListQueryGroup.Count > 0)
{
Helper.HashTableBaseClass.Add(omQuery.BaseClass, string.Empty);
}
for (int i = 0; i < listOMQueryGroup.Count; i++)
{
//Add DataGridViewGrop
omGroup = listOMQueryGroup[i];
group = i != 0 ? AddDataGridViewToPanel() : defaultGroup;
for (int j = 0; j < omGroup.ListQueryClauses.Count; j++)
{
//Get the clauses from the group
OMQueryClause omQueryClause = omGroup.ListQueryClauses[j];
dbDataGridView gridQuery = group.DataGridViewQuery;
gridQuery.Rows.Add(1);
ProxyType fieldType = AssemblyInspectorObject.DataType.ResolveType(omQueryClause.FieldType);
//Fill the Conditions depending upon the field name
gridQuery.FillConditionsCombobox(fieldType, j);
gridQuery.FillOperatorComboBox();
gridQuery.Rows[j].Cells[Helper.GetResourceString(Constants.QUERY_GRID_FIELD)].Value = omQueryClause.Fieldname;
gridQuery.Rows[j].Cells[Helper.GetResourceString(Constants.QUERY_GRID_CONDITION)].Value = omQueryClause.Operator;
gridQuery.Rows[j].Cells[Helper.GetResourceString(Constants.QUERY_GRID_VALUE)].Value = omQueryClause.Value;
gridQuery.Rows[j].Cells[Helper.GetResourceString(Constants.QUERY_GRID_OPERATOR)].Value = omQueryClause.ClauseLogicalOperator.ToString();
//Make the operator cell readonly for other than 1st Rows
if (j > 0)
gridQuery.Rows[j].Cells[Helper.GetResourceString(Constants.QUERY_GRID_OPERATOR)].ReadOnly = true;
gridQuery.Rows[j].Cells[Constants.QUERY_GRID_CALSSNAME_HIDDEN].Value = omQueryClause.Classname;
gridQuery.Rows[j].Cells[Constants.QUERY_GRID_FIELDTYPE_HIDDEN].Value = fieldType.DisplayName;
gridQuery.Rows[j].Cells[Constants.QUERY_GRID_FIELDTYPE_DISPLAY_HIDDEN].Value = fieldType;
}
//Set the logical operator for Query Group
group.OperatorComboBox.SelectedItem = omGroup.GroupLogicalOperator.ToString();
if (group.DataGridViewQuery.Rows.Count > 0)
buttonRunQuery.Enabled = true;
}
listQueryAttributes = omQuery.AttributeList;
int count = 0;
if (listQueryAttributes != null)
{
IDictionaryEnumerator enumerator = listQueryAttributes.GetEnumerator();
while (enumerator.MoveNext())
{
dbDataGridAttributes.Rows.Add(1);
dbDataGridAttributes.Rows[count].Cells[0].Value = enumerator.Key.ToString();
dbDataGridAttributes.Rows[count].Cells[0].Tag = enumerator.Value.ToString();
count++;
}
}
OMETrace.WriteFunctionEnd();
}
}
catch (Exception oEx)
{
LoggingHelper.ShowMessage(oEx);
}
}
public static List <Hashtable> ExecuteQueryResults(OMQuery omQuery, PagingData pgData, bool refresh, Hashtable attributeList)
{
RunQuery.ExecuteQuery(omQuery);
return(ReturnQueryResults(pgData, refresh, omQuery.BaseClass, attributeList));
}
public static void AddQueriesToList(OMQuery query)
{
ManageConnectionDetails manage = new ManageConnectionDetails(GetCurrentConnParams());
manage.AddQueryToList(query);
}
/// <summary>
/// Sets the OMQuery to the cached list
/// </summary>
/// <param name="omQuery"></param>
private static void SetOMQuery(OMQuery omQuery)
{
try
{
if (Helper.OMResultedQuery.ContainsKey(omQuery.BaseClass))
{
Helper.OMResultedQuery[omQuery.BaseClass] = omQuery;
}
else
{
Helper.OMResultedQuery.Add(omQuery.BaseClass, omQuery);
}
}
catch (Exception oEx)
{
LoggingHelper.ShowMessage(oEx);
}
}
public QueryParser(OMQuery OmQuery)
{
objectContainer = Db4oClient.Client;
m_OmQuery = OmQuery;
}
private void ExecuteQuery()
{
omQuery = new OMQuery(Helper.BaseClass, DateTime.Now);
try
{
string errorMessage;
//Check the for valid query. user must specifies the values for each query expression
bool isValidQuery = IsValidQuery(out errorMessage);
if (!isValidQuery)
{
MessageBox.Show(errorMessage,
Helper.GetResourceString(Constants.PRODUCT_CAPTION),
MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
omQuery = PrepareOMQuery();
AddQueryToCurrentConnection(omQuery);
ObjectBrowser.Instance.Enabled = false;
PropertiesTab.Instance.Enabled = false;
Instance.Enabled = false;
EnableDisableDatabaseConnection(false);
bw = new BackgroundWorker();
bw.WorkerReportsProgress = true;
bw.WorkerSupportsCancellation = true;
bw.ProgressChanged += bw_ProgressChanged;
bw.DoWork += bw_DoWork;
bw.RunWorkerCompleted += bw_RunWorkerCompleted;
bw.RunWorkerAsync();
ApplicationObject.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationBuild);
isrunning = true;
}
catch (Exception oEx)
{
LoggingHelper.ShowMessage(oEx);
ClearStatusBar();
}
}
/// <summary>
/// Show the result for selected class in both case Run Query/View Objects
/// </summary>
private void ShowObjectsForAClass()
{
try
{
queryBuilder = ((ViewBase.GetWindow(Constants.QUERYBUILDER)).Object) as QueryBuilder;
listQueryAttributes = queryBuilder.GetSelectedAttributes();
//Only Set BaseClass with current class
if (toolStripButtonAssemblyView.Checked)
{
Helper.BaseClass = dbAssemblyTreeView.SelectedNode.Parent != null
? dbAssemblyTreeView.SelectedNode.Text
: Helper.ClassName;
}
else
{
Helper.BaseClass = dbtreeviewObject.SelectedNode.Parent != null
? dbtreeviewObject.SelectedNode.Text
: Helper.ClassName;
}
//Prepare query for View Objects
omQuery = new OMQuery(Helper.BaseClass, DateTime.Now);
if (Helper.HashTableBaseClass.Contains(Helper.BaseClass))
{
omQuery.AttributeList = listQueryAttributes;
}
//Need to fectch attribute list in query result for same OMQuery
if (Helper.OMResultedQuery.Contains(omQuery.BaseClass))
{
Helper.OMResultedQuery[omQuery.BaseClass] = omQuery;
}
else
{
Helper.OMResultedQuery.Add(omQuery.BaseClass, omQuery);
}
dbtreeviewObject.UpdateTreeNodeSelection(dbtreeviewObject.SelectedNode, toolStripButtonAssemblyView.Checked);
ApplicationObject.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationBuild);
if (backgroundWorkerToRunQuery.IsBusy)
{
backgroundWorkerToRunQuery.CancelAsync();
}
else
{
backgroundWorkerToRunQuery.RunWorkerAsync();
}
isrunning = true;
}
catch (Exception oEx)
{
LoggingHelper.ShowMessage(oEx);
}
}
public static void AddQueriesToList(OMQuery query)
{
ManageConnectionDetails manage = new ManageConnectionDetails(GetCurrentConnParams());
manage.AddQueryToList(query);
}
public QueryParser(OMQuery OmQuery)
{
objectContainer = Db4oClient.Client;
m_OmQuery = OmQuery;
}
//public RecentQueries PopulateParameters(DateTime date)
//{
// this.Timestamp = date;
// this.ConnParam = m_connParam;
// return this;
//}
public void AddQueryToList(OMQuery query)
{
try
{
container = Db4oClient.RecentConn;
if (QueryList != null)
{
CompareQueryTimestamps comp = new CompareQueryTimestamps();
List <OMQuery> qList = FetchAllQueries();
// qList.Sort(comp);
if (qList.Count >= 20)
{
bool check = false;
foreach (OMQuery qry in qList)
{
if (qry.QueryString == query.QueryString)
{
//check if the query string is among 5
check = true;
}
}
//if it is not among five then remove the last item from the list
if (check == false)
{
OMQuery q = qList[qList.Count - 1];
qList.RemoveAt(qList.Count - 1);
foreach (OMQuery qry1 in this.QueryList)
{
if (q.QueryString.Equals(qry1.QueryString))
{
this.QueryList.Remove(qry1);
break;
}
}
container.Delete(q);
container.Commit();
}
}
List <OMQuery> qListForClass = FetchQueriesForAClass(query.BaseClass);
if (qListForClass != null)
{
qListForClass.Sort(comp);
if (qListForClass.Count >= 5)
{
bool check = false;
foreach (OMQuery qry in qListForClass)
{
if (qry.QueryString == query.QueryString)
{
//check if the query string is among 5
check = true;
}
}
//if it is not among five then remove the last item from the list
if (check == false)
{
OMQuery q = qListForClass[qListForClass.Count - 1];
qListForClass.RemoveAt(qListForClass.Count - 1);
foreach (OMQuery qry1 in this.QueryList)
{
if (q.QueryString.Equals(qry1.QueryString))
{
this.QueryList.Remove(qry1);
break;
}
}
container.Delete(q);
container.Commit();
}
}
// recent queries should always be 5 for a class therefore its checked
//against qListForClass.
foreach (OMQuery q in qListForClass)
{
if (q != null)
{
if (q.QueryString != null)
{
if (q.QueryString.Equals(query.QueryString))
{
//if query string is same as already in the list then remove from the list
//so that same string can be added again with updated timestamp
foreach (OMQuery qry1 in this.QueryList)
{
if (q.QueryString.Equals(qry1.QueryString))
{
this.QueryList.Remove(qry1);
break;
}
}
}
}
}
}
}
//add query with latest timestamp.
this.QueryList.Add(query);
RecentQueries temprc = this.ChkIfRecentConnIsInDb();
if (temprc != null)
{
temprc.Timestamp = DateTime.Now;
temprc.QueryList = this.QueryList;
}
else
{
temprc = this;
temprc.m_TimeOfCreation = Sharpen.Runtime.CurrentTimeMillis();
}
container.Ext().Store(temprc, 5);
container.Commit();
container = null;
Db4oClient.CloseRecentConnectionFile();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
container = null;
Db4oClient.CloseRecentConnectionFile();
}
}
public static long[] ExecuteQueryResults(OMQuery omQuery)
{
return RunQuery.ExecuteQuery(omQuery);
}
