public string GetSearchRequest(ISearchExpression expression, bool onlyMy = true) { var queryBuilder = QueryBuilderImpl.CreateEmptyQueryBuilder(); var currentUser = _context.GetCurrentPerson(); var currentUserPositions = currentUser.Positions.ToArray(); var allTasksTypes = _taskTypesService.AllTaskTypes .Union(_taskTypesService.AllWorkflowTypes) .ToArray(); var types = GetTypesFromExpression <NextTaskTypeArgumentToken>(expression, allTasksTypes, out _); queryBuilder.Must(ObjectFields.TypeId.BeAnyOf(types.Select(x => x.Id).ToArray())); AddAttributesSearch(expression, queryBuilder); var myToken = expression.Tokens.OfType <NextTaskMySearchToken>().ToList(); if ((!currentUser.IsAdmin && onlyMy) || (!currentUser.IsAdmin && !onlyMy && myToken.Any()) || (currentUser.IsAdmin && myToken.Any())) { var occur = myToken.FirstOrDefault()?.Context?.GetTermOccur() ?? TermOccur.Must; var searchObjects = new List <ISearchTerm>(); var attributeNames = new HashSet <string>(); foreach (var name in allTasksTypes) { attributeNames.UnionWith(name.Attributes.Where(x => x.Type == MAttrType.OrgUnit).Select(x => x.Name)); } foreach (var attribute in attributeNames) { var field = AttributeFields.OrgUnit(attribute); searchObjects.Add(field.BeAnyOf(currentUserPositions)); } queryBuilder.AddAnyOf(searchObjects.ToArray(), occur); } var searchPhraseTokens = expression.Tokens.OfType <NextTaskSearchPhraseToken>(); foreach (var tokenGroup in searchPhraseTokens.GroupBy(x => x.Context.GetTermOccur())) { var keywords = tokenGroup.Select(x => EscapeKeyword(x.Value)).ToList(); foreach (var keyword in keywords) { queryBuilder.Add(ObjectFields.AllText.Be(keyword), tokenGroup.Key); } } var quotedSearchPhraseTokens = expression.Tokens.OfType <NextTaskQuotedSearchPhraseToken>(); foreach (var tokenGroup in quotedSearchPhraseTokens.GroupBy(x => x.Context.GetTermOccur())) { var keywords = tokenGroup.Select(x => EscapeSearchPhrase(x.Value)).ToList(); foreach (var keyword in keywords) { queryBuilder.Add(ObjectFields.AllText.Be(keyword), tokenGroup.Key); } } return(queryBuilder.ToString()); }
private ISearchExpression RemoveParentSelectAsExpression(ISearchExpression exp) { if (m_parentSm.SelectAsColumns == null) /* || m_innerSearchManager.Count == 0) */ // 不知道为什么有这句话 { return(exp); } Feng.Search.LogicalExpression le = exp as Feng.Search.LogicalExpression; if (le != null) { ISearchExpression sel = RemoveParentSelectAsExpression(le.LeftHandSide); ISearchExpression ser = RemoveParentSelectAsExpression(le.RightHandSide); return(new Feng.Search.LogicalExpression(sel, ser, le.LogicOperator)); } else { Feng.Search.SimpleExpression se = exp as Feng.Search.SimpleExpression; if (se != null) { if (m_parentSm.SelectAsColumns.ContainsKey(se.FullPropertyName)) { return(SearchExpression.True()); } else { return(se); } } } return(null); }
/// <summary> /// 查询数据条数 /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public override int GetCount(ISearchExpression searchExpression) { using (var rep = new Repository(this.RepositoryCfgName)) { return(GetCount(searchExpression, rep.Session)); } }
/// <summary> /// 查询数据 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <returns></returns> public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders) { using (var rep = new Repository(this.RepositoryCfgName)) { return(GetData(searchExpression, searchOrders, rep.Session)); } }
/// <summary> /// 根据查询条件读入数据 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> protected override void GetDataCount(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders) { System.Data.DataTable dt = GetData(searchExpression, searchOrders) as System.Data.DataTable; if (this.EnablePage && m_dataCanPage) { base.Count = GetCount(searchExpression); } else { base.Count = dt.Rows.Count; } // 需要分页但数据库读取不能分页的时候,读出全部数据然后选择性返回 if (this.EnablePage && !m_dataCanPage) { System.Data.DataTable dt2 = dt.Clone(); for (int i = 0; i < Math.Min(dt.Rows.Count, this.MaxResult); ++i) { dt2.ImportRow(dt.Rows[i + this.FirstResult]); } base.Result = dt2.DefaultView; } else { base.Result = dt.DefaultView; } }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <param name="parentItem"></param> public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders, object parentItem) { IList <T> list; object masterItem = parentItem; if (masterItem != null) { if (masterItem.GetType() == typeof(T)) { list = new List <T>(); list.Add((T)masterItem); } else { using (var rep = new Repository(this.RepositoryCfgName)) { rep.BeginTransaction(); object id = EntityScript.GetPropertyValue(masterItem, TypedEntityMetadata.GenerateEntityInfo(rep.Session.SessionFactory, masterItem.GetType()).IdName); NHibernate.ICriteria criteria = rep.Session.CreateCriteria(typeof(T)) .Add(NHibernate.Criterion.Expression.IdEq(id)); OnCriteriaCreated(criteria); list = criteria.List <T>(); rep.CommitTransaction(); } } } else { list = new List <T>(); } return(list); }
/// <summary> /// 根据查询条件查询数据 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <returns></returns> public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders) { System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders)); dt.TableName = m_tableName; return(dt.DefaultView); }
/// <summary> /// 读入数据 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> protected override void GetDataCount(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders) { System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders)); dt.TableName = m_tableName; if (this.EnablePage && m_dataCanPage) { base.Count = GetCount(searchExpression); } else { base.Count = dt.Rows.Count; } // 需要分页但数据库读取不能分页的时候,读出全部数据然后选择性返回 if (this.EnablePage && !m_dataCanPage) { System.Data.DataTable dt2 = dt.Clone(); for (int i = 0; i < Math.Min(dt.Rows.Count - this.FirstResult, this.MaxResult); ++i) { dt2.ImportRow(dt.Rows[i + this.FirstResult]); } this.Result = dt2.DefaultView; } else { this.Result = dt.DefaultView; } }
private ISearchExpression ParseComplexExpression() { ISearchExpression expression = null; switch (this.token) { case TokenType.LeftParenthesis: this.MoveNext(); ISearchExpression c = this.ParseOrOperator(); this.AssertTokenType(TokenType.RightParenthesis); expression = c; break; case TokenType.Not: this.MoveNext(); expression = new LogicalExpression(this.ParseComplexExpression(), null, LogicalOperator.Not); break; default: expression = ParseSimpleExpression(); break; } return(expression); }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <param name="func"></param> protected override void GetDataCount(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders, Action <object> func) { List <T> dataSource = new List <T>(); int count; using (var rep = new Repository(this.RepositoryCfgName)) //using (var tx = rep.BeginTransaction(System.Data.IsolationLevel.ReadCommitted)) { rep.BeginTransaction(); ActionableList <object> actionList = new ActionableList <object>(dataSource, func); GetData(searchExpression, searchOrders, rep.Session, actionList); // 当不是第一页的时候,不能通过返回条数当作总条数 if (this.EnablePage && this.FirstResult == 0 && dataSource.Count < this.MaxResult) { count = dataSource.Count; } else { count = GetCount(searchExpression, rep.Session); } rep.CommitTransaction(); } base.Count = count; base.Result = dataSource; }
internal static Dictionary <string, object> GetSearchExpreesionValues(ISearchExpression se) { Dictionary <string, object> ret = new Dictionary <string, object>(); Feng.Search.LogicalExpression le = se as Feng.Search.LogicalExpression; if (le != null) { Dictionary <string, object> r = GetSearchExpreesionValues(le.LeftHandSide); foreach (KeyValuePair <string, object> kvp in r) { ret[kvp.Key] = kvp.Value; } r = GetSearchExpreesionValues(le.RightHandSide); foreach (KeyValuePair <string, object> kvp in r) { ret[kvp.Key] = kvp.Value; } } else { Feng.Search.SimpleExpression ce = se as Feng.Search.SimpleExpression; ret[ce.FullPropertyName + ce.Operator.ToString()] = ce.Values; } return(ret); }
/// <summary> /// 读入数据 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> protected override void GetDataCount(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders) { System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders)); base.Result = dt.DefaultView; base.Count = dt.Rows.Count; }
/// <summary> /// 把SearchExpression分解成SimpleExpression列表 /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public static IList <SimpleExpression> GetSimpleExpressions(ISearchExpression searchExpression) { List <SimpleExpression> list = new List <SimpleExpression>(); GetSimpleExpressions(searchExpression, list); return(list); }
public string ToInvariantExpressionString(ISearchExpression expression) { var sb = new StringBuilder(); foreach (var token in expression.Tokens) { var keywordToken = token as IKeywordToken; if (keywordToken != null) { sb.Append(keywordToken.SerializationAlias); continue; } var argumentToken = token as IArgumentToken; if (argumentToken != null) { sb.Append(argumentToken.Id ?? argumentToken.Value); continue; } throw new InvalidOperationException("unknown token class"); } return(sb.ToString()); }
public void Visit(ISearchExpression expression) { var p = expression as ISearchExpression; string lf = ""; string lv = ""; string rf = ""; string rv = ""; if (p.Left != null || p.Right != null) { if (p.Left != null) { lf = p.Left.FieldName; lv = p.Left.Value; } if (p.Right != null) { rf = p.Right.FieldName; rv = p.Right.Value; } param.Add(String.Format("LEFT Field: {0} Value: {1} {2} RIGHT Field: {3} Value: {4}", lf, lv, p.ExpressionType, rf, rv)); Count++; } }
internal void GetDataCountInternal(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders) { IList <T> dataSource; int count; using (var rep = new Repository(this.RepositoryCfgName)) //using (var tx = rep.BeginTransaction(System.Data.IsolationLevel.ReadCommitted)) { rep.BeginTransaction(); dataSource = GetData(searchExpression, searchOrders, rep.Session) as IList <T>; // 当不是第一页的时候,不能通过返回条数当作总条数 if (this.EnablePage && this.FirstResult == 0 && dataSource.Count < this.MaxResult) { count = dataSource.Count; } else { count = GetCount(searchExpression, rep.Session); } rep.CommitTransaction(); } base.Count = count; base.Result = dataSource; }
/// <summary> /// 以entities为数据打印(例如滞箱费减免联系单) /// </summary> /// <param name="entities"></param> public void FillDataSet(object[] entities) { ISearchExpression se = null; foreach (object entity in entities) { if (se == null) { se = SearchExpression.Parse(EntityHelper.ReplaceEntity(m_reportInfo.SearchExpression, entity)); } else { se = SearchExpression.Or(se, SearchExpression.Parse(EntityHelper.ReplaceEntity(m_reportInfo.SearchExpression, entity))); } } for (int i = 0; i < m_reportDataInfos.Count; ++i) { object data = m_sms[i].GetData(se, null); System.Collections.IEnumerable dataList = data as System.Collections.IEnumerable; if (dataList == null) { dataList = (data as System.Data.DataTable).DefaultView; } FillDataSet(i, dataList); } }
/// <summary> /// 根据查询条件创建Sql命令 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <returns></returns> public virtual DbCommand CreateDbCommand(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders) { DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand(); cmd.CommandType = System.Data.CommandType.Text; if (searchExpression is QueryExpression) { string s = (searchExpression as QueryExpression).Query; cmd.CommandText = s; } else { int paramCnt = 0; if (this.EnablePage && m_dataCanPage) { } else { cmd.CommandText = m_selectSql; // Add Where if (searchExpression != null) { string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, false, ref paramCnt, m_selectAsColumns); if (!string.IsNullOrEmpty(s)) { cmd.CommandText += " WHERE " + s; } } string groupBy = SearchManager.GetGroupCommand(m_groupBySql); if (!string.IsNullOrEmpty(groupBy)) { cmd.CommandText += groupBy; // Add Having if (searchExpression != null) { string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, true, ref paramCnt, m_selectAsColumns); if (!string.IsNullOrEmpty(s)) { cmd.CommandText += " HAVING " + s; } } } cmd.CommandText += SearchManager.GetSqlOrders(searchOrders, false, null); } if (paramCnt > 2100) { throw new NotSupportedException("您输入的参数过多,系统最多只支持2100个参数!"); } } return(cmd); }
private ObjectState[] GetObjectStates(ISearchExpression expression) { var stateToken = expression.Tokens.OfType <StateArgumentToken>().FirstOrDefault(); return(stateToken != null ? new[] { (ObjectState)Enum.Parse(typeof(ObjectState), stateToken.Id, true) } : new[] { ObjectState.Alive, ObjectState.Frozen }); }
private void GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders, NHibernate.ISession session, ActionableList <object> actionList) { NHibernate.ICriteria criteria = CreateCriteria(session, searchExpression, searchOrders, ref m_hasCollection); OnCriteriaCreated(criteria); criteria.List(actionList); }
private System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList <ISearchOrder> searchOrders, NHibernate.ISession session) { NHibernate.ICriteria criteria = CreateCriteria(session, searchExpression, searchOrders, ref m_hasCollection); OnCriteriaCreated(criteria); return(criteria.List <T>()); //return criteria.Future<T>(); }
internal static void ShowFrom(string actionId, ISearchExpression se, bool asDetailDialog) { IDisplayManagerContainer seeForm = null; ArchiveDetailForm detailForm = null; ISearchManager sm = null; if (!asDetailDialog) { seeForm = (ServiceProvider.GetService <IApplication>() as IWinFormApplication).ExecuteAction(actionId) as IDisplayManagerContainer; if (seeForm == null) { throw new InvalidOperationException("未能创建目标窗体!"); } sm = seeForm.DisplayManager.SearchManager; } else { //detailForm = Feng.Utils.ReflectionHelper.CreateInstanceFromType(Feng.Utils.ReflectionHelper.GetTypeFromName(info.ToDetailForm)) as ArchiveDetailForm; //if (detailForm == null) //{ // MessageForm.ShowError("未能创建目标窗体!"); // return; //} //detailForm.UpdateContent(); //findWindow = detailForm.DisplayManager.SearchManager; } if (sm == null) { throw new InvalidOperationException("未能找到目标窗体的查找窗口!"); } //List<ISearchExpression> findList = new List<ISearchExpression>(); //ISearchExpression findCondition = GetAndFindCondition(selected, 0, toColumns); //for (int i = 1; i < selected[0].Count; ++i) //{ // findCondition = new LogicalExpression(findCondition, GetAndFindCondition(selected, i, toColumns), LogicalOperator.Or); //} //findList.Add(findCondition); sm.LoadData(se, null); if (asDetailDialog) { if (detailForm.ControlManager.DisplayManager.Count == 0) { ServiceProvider.GetService <IMessageBox>().ShowWarning("未能找到相应记录!"); return; } detailForm.ControlManager.DisplayManager.Position = 0; detailForm.ShowDialog(); detailForm.Dispose(); } }
protected void AddDateSearch( Func <TokenBase, bool> tokenFilter, Func <DatesRangeLimits, ISearchTerm> toObjectSearchTerm, Func <DatesRangeLimits, ISearchTerm> toFileSearchTerm, ISearchExpression expression, IQueryBuilder attributesQueryBuilder, IQueryBuilder filesQueryBuilder) { var dateRangeTokens = expression.Tokens.OfType <TokenBase>().Where(x => tokenFilter(x)).ToList(); var dateRangeGroups = dateRangeTokens.GroupBy(x => x.Context[RangeToken.RangeGroupKey].Value).Where(g => g.Key != null); var dateRanges = new List <DatesRangeLimits>(); foreach (var group in dateRangeGroups) { var dateTextPresetToken = (DateTextArgumentToken)group.FirstOrDefault(x => x is DateTextArgumentToken); if (dateTextPresetToken != null) { var presetRange = DatesRangeLimits.GetRangeLimits(dateTextPresetToken); dateRanges.Add(presetRange); continue; } var groupTail = group.Last(); var from = groupTail.Context[RangeToken.FromValueKey].Value; var to = groupTail.Context[RangeToken.ToValueKey].Value; if (from == null || to == null) { continue; } var range = new DatesRangeLimits((DateTime)from, (DateTime)to); if (groupTail.Context[RangeToken.RangeKindKey].Value is DateAttributeGreaterToken) { range = DatesRangeLimits.GreaterThanRange(range); } if (groupTail.Context[RangeToken.RangeKindKey].Value is DateAttributeLessToken) { range = DatesRangeLimits.LessThanRange(range); } dateRanges.Add(range); } if (!dateRanges.Any()) { return; } var context = dateRangeTokens.First().Context; attributesQueryBuilder?.AddAnyOf(dateRanges.Select(toObjectSearchTerm).ToArray(), context.GetTermOccur()); filesQueryBuilder?.AddAnyOf(dateRanges.Select(toFileSearchTerm).ToArray(), context.GetTermOccur()); }
public ISearchExpression Or(ISearchExpression expression) { this.Left = new SearchExpression(this.FieldName, this.Value, this.Left, this.Right, this.ExpressionType); this.Right = expression; this.ExpressionType = ExpressionType.Or; this.FieldName = null; this.Value = null; return(this); }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> protected virtual DbCommand CreateCountDbCommand(ISearchExpression searchExpression) { DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand(); cmd.CommandType = System.Data.CommandType.Text; if (searchExpression is QueryExpression) { string str = (searchExpression as QueryExpression).Query; str = str.ToUpper(); int idx = str.IndexOf(' '); int idx2 = str.IndexOf("FROM"); str = str.Replace(str.Substring(idx, idx2 - idx), " COUNT(*) "); cmd.CommandText = str; return(cmd); } int paramCnt = 0; cmd.CommandText = "SELECT COUNT(*) FROM " + m_tableName; // Add Where if (searchExpression != null) { string s = FillDbCommand(searchExpression, cmd.Parameters, false, ref paramCnt, m_selectAsColumns); if (!string.IsNullOrEmpty(s)) { cmd.CommandText += " WHERE " + s; } } string groupBy = GetGroupCommand(m_groupBySql); if (!string.IsNullOrEmpty(groupBy)) { cmd.CommandText += groupBy; // Add Having if (searchExpression != null) { string s = FillDbCommand(searchExpression, cmd.Parameters, true, ref paramCnt, m_selectAsColumns); if (!string.IsNullOrEmpty(s)) { cmd.CommandText += " HAVING " + s; } } } if (paramCnt > 2100) { throw new NotSupportedException("您输入的参数过多,系统最多只支持2100个参数!"); } return(cmd); }
/// <summary> /// ToString /// </summary> /// <param name="searchExpressions"></param> /// <returns></returns> public static string ToString(ISearchExpression searchExpressions) { if (searchExpressions == null) { return(string.Empty); } else { return(searchExpressions.ToString()); } }
private ISearchExpression AndIfNecessary(ISearchExpression original, ISearchExpression and) { if (original != null) { return(SearchExpression.And(original, and)); } else { return(and); } }
void smMaster_DataLoading(object sender, DataLoadingEventArgs e) { e.Cancel = true; ISearchExpression searchExpression = e.SearchExpression; IList <ISearchOrder> searchOrders = e.SearchOrders; ReportGenerator.SetParameter(this.ReportViewer.CrystalHelper, searchExpression); this.ReportViewer.OpenReport(); }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public override int GetCount(ISearchExpression searchExpression) { if (this.EnablePage && m_dataCanPage) { return((int)DbHelper.Instance.ExecuteScalar(CreateCountDbCommand(searchExpression))); } else { return(base.Count); } }
/// <summary> /// 根据可读字符串得到查询条件 /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public static IList <ISearchExpression> ParseToList(string searchExpression) { IList <ISearchExpression> ret = new List <ISearchExpression>(); ISearchExpression exp = SearchExpression.Parse(searchExpression); if (exp != null) { ret.Add(exp); } return(ret); }
/// <summary> /// 根据查询条件创建Sql命令 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <returns></returns> public DbCommand CreateDbCommand(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders) { DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand(); cmd.CommandType = System.Data.CommandType.StoredProcedure; int paramCnt = 0; cmd.CommandText = m_procedureName; FillDbCommand(searchExpression, cmd, ref paramCnt); return cmd; }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public virtual DbCommand CreateCountDbCommand(ISearchExpression searchExpression) { DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand(); cmd.CommandType = System.Data.CommandType.Text; if (searchExpression is QueryExpression) { string str = (searchExpression as QueryExpression).Query; str = str.ToUpper(); int idx = str.IndexOf("' '"); int idx2 = str.IndexOf("FROM"); str = str.Replace(str.Substring(idx, idx2 - idx), " COUNT(*) "); cmd.CommandText = str; } else { int paramCnt = 0; // Add Where if (searchExpression != null) { string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, false, ref paramCnt, m_selectAsColumns); if (!string.IsNullOrEmpty(s)) { cmd.CommandText += " WHERE " + s; } } string groupBy = SearchManager.GetGroupCommand(m_groupBySql); if (!string.IsNullOrEmpty(groupBy)) { cmd.CommandText += groupBy; // Add Having if (searchExpression != null) { string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, true, ref paramCnt, m_selectAsColumns); if (!string.IsNullOrEmpty(s)) { cmd.CommandText += " HAVING " + s; } } } if (paramCnt > 2100) { throw new NotSupportedException("您输入的参数过多,系统最多只支持2100个参数!"); } } return cmd; }
/// <summary> /// /// </summary> /// <param name="lhs"></param> /// <param name="rhs"></param> /// <returns></returns> public static ISearchExpression And(ISearchExpression lhs, ISearchExpression rhs) { if (lhs == null) { return rhs; } else if (rhs == null) { return lhs; } else { return new LogicalExpression(lhs, rhs, LogicalOperator.And); } }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> protected override DbCommand CreateCountDbCommand(ISearchExpression searchExpression) { Dictionary<string, object> dict = new Dictionary<string, object>(); ISearchExpression newSe = RemoveFunctionParamSearchExpression(searchExpression, dict); DbCommand cmd = base.CreateCountDbCommand(newSe); foreach (string funcParam in m_funcParams) { cmd.Parameters.Add(DbHelper.Instance.CreateParameter(funcParam, dict.ContainsKey(funcParam) ? dict[funcParam] : System.DBNull.Value)); } //ProcessCmd(cmd); return cmd; }
internal static Dictionary<string, object> GetSearchExpreesionValues(ISearchExpression se) { Dictionary<string, object> ret = new Dictionary<string, object>(); Feng.Search.LogicalExpression le = se as Feng.Search.LogicalExpression; if (le != null) { Dictionary<string, object> r = GetSearchExpreesionValues(le.LeftHandSide); foreach (KeyValuePair<string, object> kvp in r) { ret[kvp.Key] = kvp.Value; } r = GetSearchExpreesionValues(le.RightHandSide); foreach (KeyValuePair<string, object> kvp in r) { ret[kvp.Key] = kvp.Value; } } else { Feng.Search.SimpleExpression ce = se as Feng.Search.SimpleExpression; ret[ce.FullPropertyName + ce.Operator.ToString()] = ce.Values; } return ret; }
private static void GetSimpleExpressions(ISearchExpression searchExpression, List<SimpleExpression> list) { if (searchExpression is SimpleExpression) { list.Add(searchExpression as SimpleExpression); } else if (searchExpression is LogicalExpression) { LogicalExpression le = searchExpression as LogicalExpression; if (le.LogicOperator == LogicalOperator.And || le.LogicOperator == LogicalOperator.Or) { GetSimpleExpressions(le.LeftHandSide, list); GetSimpleExpressions(le.RightHandSide, list); } else if (le.LogicOperator == LogicalOperator.Not) { GetSimpleExpressions(le.LeftHandSide, list); } } }
internal static void SetParameter(CrystalHelper crystalHelper, ISearchExpression se) { if (se == null) return; LogicalExpression le = se as LogicalExpression; if (le != null) { SetParameter(crystalHelper, le.LeftHandSide); SetParameter(crystalHelper, le.RightHandSide); } else { SimpleExpression cse = se as SimpleExpression; string simpleParamName = "@" + cse.FullPropertyName; string complexParamName = "@" + cse.FullPropertyName + cse.Operator.ToString(); switch (cse.Operator) { case SimpleOperator.Any: case SimpleOperator.EqProperty: case SimpleOperator.IsNotNull: case SimpleOperator.IsNull: case SimpleOperator.NotEq: case SimpleOperator.NotEqProperty: case SimpleOperator.Sql: throw new ArgumentException(cse.Operator + " is not supported in procedure!"); case SimpleOperator.Ge: case SimpleOperator.Gt: case SimpleOperator.Le: case SimpleOperator.Lt: crystalHelper.SetParameter(complexParamName, cse.Values); break; case SimpleOperator.Eq: case SimpleOperator.GInG: case SimpleOperator.InG: case SimpleOperator.Like: crystalHelper.SetParameter(simpleParamName, cse.Values); break; } } }
/// <summary> /// 查询数据条数 /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public override int GetCount(ISearchExpression searchExpression) { if (this.EnablePage && m_dataCanPage) { return (int)DbHelper.Instance.ExecuteScalar(CreateCountDbCommand(searchExpression)); } else { return base.Count; } }
private ISearchExpression RemoveParentSelectAsExpression(ISearchExpression exp) { if (m_parentSm.SelectAsColumns == null) /* || m_innerSearchManager.Count == 0) */ // 不知道为什么有这句话 { return exp; } Feng.Search.LogicalExpression le = exp as Feng.Search.LogicalExpression; if (le != null) { ISearchExpression sel = RemoveParentSelectAsExpression(le.LeftHandSide); ISearchExpression ser = RemoveParentSelectAsExpression(le.RightHandSide); return new Feng.Search.LogicalExpression(sel, ser, le.LogicOperator); } else { Feng.Search.SimpleExpression se = exp as Feng.Search.SimpleExpression; if (se != null) { if (m_parentSm.SelectAsColumns.ContainsKey(se.FullPropertyName)) { return SearchExpression.True(); } else { return se; } } } return null; }
/// <summary> /// 根据查询条件创建Sql命令 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <returns></returns> public virtual DbCommand CreateDbCommand(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders) { DbCommand cmd = DbHelper.Instance.Database.DbProviderFactory.CreateCommand(); cmd.CommandType = System.Data.CommandType.Text; if (searchExpression is QueryExpression) { string s = (searchExpression as QueryExpression).Query; cmd.CommandText = s; } else { int paramCnt = 0; if (this.EnablePage && m_dataCanPage) { } else { cmd.CommandText = m_selectSql; // Add Where if (searchExpression != null) { string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, false, ref paramCnt, m_selectAsColumns); if (!string.IsNullOrEmpty(s)) { cmd.CommandText += " WHERE " + s; } } string groupBy = SearchManager.GetGroupCommand(m_groupBySql); if (!string.IsNullOrEmpty(groupBy)) { cmd.CommandText += groupBy; // Add Having if (searchExpression != null) { string s = SearchManager.FillDbCommand(searchExpression, cmd.Parameters, true, ref paramCnt, m_selectAsColumns); if (!string.IsNullOrEmpty(s)) { cmd.CommandText += " HAVING " + s; } } } cmd.CommandText += SearchManager.GetSqlOrders(searchOrders, false, null); } if (paramCnt > 2100) { throw new NotSupportedException("您输入的参数过多,系统最多只支持2100个参数!"); } } return cmd; }
/// <summary> /// Initialize a new instance of the <see cref="LogicalExpression" /> class that /// combines two other <see cref="ISearchExpression"/>s. /// </summary> /// <param name="lhs">The <see cref="ISearchExpression"/> to use in the Left Hand Side.</param> /// <param name="rhs">The <see cref="ISearchExpression"/> to use in the Right Hand Side.</param> /// <param name="op"></param> public LogicalExpression(ISearchExpression lhs, ISearchExpression rhs, LogicalOperator op) { _lhs = lhs; _rhs = rhs; _op = op; }
/// <summary> /// /// </summary> /// <param name="se"></param> /// <param name="so"></param> public DataLoadingEventArgs(ISearchExpression se, IList<ISearchOrder> so) { this.SearchExpression = se; this.SearchOrders = so; }
internal static ISearchExpression ReplaceSearchExpreesionValues(ISearchExpression se, Dictionary<string, object> dict) { Feng.Search.LogicalExpression le = se as Feng.Search.LogicalExpression; if (le != null) { ISearchExpression l = le.LeftHandSide; l = ReplaceSearchExpreesionValues(l, dict); ISearchExpression r = le.RightHandSide; r = ReplaceSearchExpreesionValues(r, dict); if (l == null) return r; else if (r == null) return l; else return new Feng.Search.LogicalExpression(l, r, le.LogicOperator); } else { Feng.Search.SimpleExpression ce = se as Feng.Search.SimpleExpression; string s = ce.Values.ToString(); if (s[0] == '%' && s[s.Length - 1] == '%') { string s1 = s.Substring(1, s.Length - 2); if (dict.ContainsKey(s1)) { ce.Values = dict[s1]; } else { ce = null; } } return ce; } }
/// <summary> /// 把SearchExpression分解成SimpleExpression列表 /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public static IList<SimpleExpression> GetSimpleExpressions(ISearchExpression searchExpression) { List<SimpleExpression> list = new List<SimpleExpression>(); GetSimpleExpressions(searchExpression, list); return list; }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public override int GetCount(ISearchExpression searchExpression) { string exp = SearchExpression.ToString(searchExpression); return m_client.GetDataCount(exp); }
private void FillDbCommand(ISearchExpression condition, DbCommand cmd, ref int paramCnt) { SimpleExpression cse = condition as SimpleExpression; if (cse == null) { LogicalExpression l = condition as LogicalExpression; FillDbCommand(l.LeftHandSide, cmd, ref paramCnt); FillDbCommand(l.RightHandSide, cmd, ref paramCnt); } else { string simpleParamName = "@" + cse.FullPropertyName; string complexParamName = "@" + cse.FullPropertyName + cse.Operator.ToString(); switch (cse.Operator) { case SimpleOperator.Any: case SimpleOperator.EqProperty: case SimpleOperator.IsNotNull: case SimpleOperator.IsNull: case SimpleOperator.NotEq: case SimpleOperator.NotEqProperty: case SimpleOperator.Sql: throw new NotSupportedException(cse.Operator + " is not supported in procedure!"); case SimpleOperator.Ge: case SimpleOperator.Gt: case SimpleOperator.Le: case SimpleOperator.Lt: cmd.Parameters.Add(DbHelper.Instance.CreateParameter(complexParamName, cse.Values)); break; case SimpleOperator.Eq: case SimpleOperator.GInG: case SimpleOperator.InG: case SimpleOperator.Like: cmd.Parameters.Add(DbHelper.Instance.CreateParameter(simpleParamName, cse.Values)); break; } paramCnt++; } }
/// <summary> /// 读入数据 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> protected override void GetDataCount(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders) { System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders)); base.Result = dt.DefaultView; base.Count = dt.Rows.Count; }
/// <summary> /// ���ݲ�ѯ������ѯ���� /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <returns></returns> public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders) { string exp = SearchExpression.ToString(searchExpression); string order = SearchOrder.ToString(searchOrders); var list = m_client.GetData(exp, order, this.FirstResult, this.MaxResult); var ret = new List<IDictionary<string, object>>(); foreach (var i in list) { ret.Add(Feng.Net.Utils.TypeHelper.ConvertTypeFromWSToDictionary(i)); } return ret; }
private ISearchExpression AndIfNecessary(ISearchExpression original, ISearchExpression and) { if (original != null) return SearchExpression.And(original, and); else return and; }
/// <summary> /// ToString /// </summary> /// <param name="searchExpressions"></param> /// <returns></returns> public static string ToString(ISearchExpression searchExpressions) { if (searchExpressions == null) { return string.Empty; } else { return searchExpressions.ToString(); } }
internal static void ShowFrom(string actionId, ISearchExpression se, bool asDetailDialog) { IDisplayManagerContainer seeForm = null; ArchiveDetailForm detailForm = null; ISearchManager sm = null; if (!asDetailDialog) { seeForm = (ServiceProvider.GetService<IApplication>() as IWinFormApplication).ExecuteAction(actionId) as IDisplayManagerContainer; if (seeForm == null) { throw new InvalidOperationException("未能创建目标窗体!"); } sm = seeForm.DisplayManager.SearchManager; } else { //detailForm = Feng.Utils.ReflectionHelper.CreateInstanceFromType(Feng.Utils.ReflectionHelper.GetTypeFromName(info.ToDetailForm)) as ArchiveDetailForm; //if (detailForm == null) //{ // MessageForm.ShowError("未能创建目标窗体!"); // return; //} //detailForm.UpdateContent(); //findWindow = detailForm.DisplayManager.SearchManager; } if (sm == null) { throw new InvalidOperationException("未能找到目标窗体的查找窗口!"); } //List<ISearchExpression> findList = new List<ISearchExpression>(); //ISearchExpression findCondition = GetAndFindCondition(selected, 0, toColumns); //for (int i = 1; i < selected[0].Count; ++i) //{ // findCondition = new LogicalExpression(findCondition, GetAndFindCondition(selected, i, toColumns), LogicalOperator.Or); //} //findList.Add(findCondition); sm.LoadData(se, null); if (asDetailDialog) { if (detailForm.ControlManager.DisplayManager.Count == 0) { ServiceProvider.GetService<IMessageBox>().ShowWarning("未能找到相应记录!"); return; } detailForm.ControlManager.DisplayManager.Position = 0; detailForm.ShowDialog(); detailForm.Dispose(); } }
/// <summary> /// �������� /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> protected override void GetDataCount(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders) { base.Result = GetData(searchExpression, searchOrders); base.Count = GetCount(searchExpression); }
///// <summary> ///// Constructor ///// </summary> ///// <param name="cmParent"></param> //public SearchManagerProxyDetailInMaster(IControlManager cmParent) // : base(cmParent) //{ //} /// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <param name="parentItem"></param> /// <returns></returns> public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders, object parentItem) { if (parentItem == null) { return null; } string exp = EntityHelper.ReplaceEntity(m_searchExpression, parentItem); searchExpression = SearchExpression.And(SearchExpression.Parse(exp), searchExpression); if (!string.IsNullOrEmpty(m_searchOrder)) { return m_innerSearchManager.GetData(searchExpression, SearchOrder.Parse(m_searchOrder)); } else { return m_innerSearchManager.GetData(searchExpression, null); } }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <param name="parentItem"></param> /// <returns></returns> public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders, object parentItem) { if (parentItem == null) { return null; } SearchHistoryInfo his = this.ParentDisplayManager.SearchManager.GetHistory(0); if (!string.IsNullOrEmpty(his.Expression)) { ISearchExpression exp = SearchExpression.Parse(his.Expression); exp = RemoveParentSelectAsExpression(exp); searchExpression = SearchExpression.And(searchExpression, exp); } foreach (string s in m_groupByColumns) { object r = EntityScript.GetPropertyValue(parentItem, s); ISearchExpression se2; if (r != null && r != System.DBNull.Value) { se2 = SearchExpression.Eq(s, EntityScript.GetPropertyValue(parentItem, s)); } else { se2 = SearchExpression.IsNull(s); } searchExpression = SearchExpression.And(searchExpression, se2); } this.SetHistory(searchExpression, searchOrders); return m_innerSearchManager.GetData(searchExpression, searchOrders); }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders) { object row = this.ParentDisplayManager.CurrentItem; return GetData(searchExpression, searchOrders, row); }
//private void ProcessCmd(DbCommand cmd) //{ // foreach (string s in m_funcParams) // { // if (!cmd.Parameters.Contains(s)) // { // cmd.CommandText = cmd.CommandText.Replace(s, "default"); // } // else // { // // remove like % // string likeString = cmd.Parameters[s].Value as string; // if (!string.IsNullOrEmpty(likeString)) // { // if (likeString[0] == '%' && likeString[likeString.Length - 1] == '%') // { // cmd.Parameters[s].Value = likeString.Substring(1, likeString.Length - 2); // } // } // // remove where clause // int idx = cmd.CommandText.IndexOf("WHERE"); // idx = cmd.CommandText.IndexOf(s, idx); // int idx2 = idx; // // jump to "=, >=" // idx2--; // while (cmd.CommandText[idx2] == ' ') // idx2--; // // jump to space // idx2--; // while (cmd.CommandText[idx2] != ' ') // idx2--; // // jump to propertyName // idx2--; // while (cmd.CommandText[idx2] == ' ') // idx2--; // // jump to space // idx2--; // while (cmd.CommandText[idx2] != ' ') // idx2--; // cmd.CommandText = cmd.CommandText.Replace(cmd.CommandText.Substring(idx2 + 1, idx - idx2 - 1 + s.Length), "1 = 1"); // } // } //} private ISearchExpression RemoveFunctionParamSearchExpression(ISearchExpression se, Dictionary<string, object> deletedParam) { if (se == null) return null; if (se is LogicalExpression) { LogicalExpression le = se as LogicalExpression; ISearchExpression ls = RemoveFunctionParamSearchExpression(le.LeftHandSide, deletedParam); ISearchExpression rs = RemoveFunctionParamSearchExpression(le.RightHandSide, deletedParam); switch (le.LogicOperator) { case LogicalOperator.And: return SearchExpression.And(ls, rs); case LogicalOperator.Or: return SearchExpression.Or(ls, rs); case LogicalOperator.Not: return SearchExpression.Not(ls); default: throw new NotSupportedException("Not Supported LogicalOperator!"); } } else if (se is SimpleExpression) { SimpleExpression cse = se as SimpleExpression; string paramName = SearchManager.CreateParamName(cse, null); if (Array.IndexOf(m_funcParams, paramName) != -1) { deletedParam[paramName] = cse.Values; return null; } else { return cse; } } else { return se; } }
/// <summary> /// /// </summary> /// <param name="hs"></param> /// <returns></returns> public static ISearchExpression Not(ISearchExpression hs) { return new LogicalExpression(hs, null, LogicalOperator.Not); }
/// <summary> /// /// </summary> /// <param name="searchExpression"></param> /// <returns></returns> public override int GetCount(ISearchExpression searchExpression) { System.Data.DataTable dt = DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, null)); return dt.Rows.Count; }
/// <summary> /// 根据查询条件查询数据 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> /// <returns></returns> public override System.Collections.IEnumerable GetData(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders) { return DbHelper.Instance.ExecuteDataTable(CreateDbCommand(searchExpression, searchOrders)).DefaultView; }
/// <summary> /// 根据查询条件读入数据 /// </summary> /// <param name="searchExpression"></param> /// <param name="searchOrders"></param> protected override void GetDataCount(ISearchExpression searchExpression, IList<ISearchOrder> searchOrders) { System.Data.DataTable dt = GetData(searchExpression, searchOrders) as System.Data.DataTable; if (this.EnablePage && m_dataCanPage) { base.Count = GetCount(searchExpression); } else { base.Count = dt.Rows.Count; } // 需要分页但数据库读取不能分页的时候,读出全部数据然后选择性返回 if (this.EnablePage && !m_dataCanPage) { System.Data.DataTable dt2 = dt.Clone(); for (int i = 0; i < Math.Min(dt.Rows.Count, this.MaxResult); ++i) { dt2.ImportRow(dt.Rows[i + this.FirstResult]); } base.Result = dt2.DefaultView; } else { base.Result = dt.DefaultView; } }