public override IQueryResult ExecuteQuery(QQuery query) { Transaction trans = query.Transaction(); query.CaptureQueryResultConfig(); query.Marshall(); MsgD msg = Msg.QueryExecute.GetWriter(Serializer.Marshall(trans, query)); Write(msg); return(ReadQueryResult(trans)); }
//private void toolExpression_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e) //{ // QQuery exp = e.ClickedItem.Tag as QQuery; // Query = exp; //} private void ToolParseClick(object sender, EventArgs e) { if (Query == null) { Query = new QQuery(); } var test = textQuery.PlainText; Query.Parse(test); }
public static IEnumerable <UserReg> GetOld(User User) { var filter = new QQuery(string.Empty, UserReg.DBTable); filter.BuildPropertyParam(nameof(UserReg.UserId), CompareType.Equal, User.PrimaryId); filter.BuildPropertyParam(nameof(UserReg.RegType), CompareType.Equal, UserRegType.Password); filter.Orders.Add(new QOrder { Column = UserReg.DBTable.ParseProperty(nameof(UserReg.Id)), Direction = ListSortDirection.Descending }); return(UserReg.DBTable.Load(filter, DBLoadParam.Load | DBLoadParam.Synchronize)); }
public Balance GetBalance(object typeid) { var filter = new QQuery("", Balance.DBTable); filter.BuildPropertyParam(nameof(Balance.AccountId), CompareType.Equal, PrimaryId); filter.BuildPropertyParam(nameof(Balance.TypeId), CompareType.Equal, typeid); var balances = Balance.DBTable.Load(filter, DBLoadParam.Load | DBLoadParam.Synchronize).ToList(); balances.Sort(new DBComparer <Balance, DateTime?>(Balance.BalanceDateKey, ListSortDirection.Descending)); return(balances.FirstOrDefault()); }
public static void SynchMessage() { if (MessageAddress.DBTable == null) { return; } var query = new QQuery(string.Empty, MessageAddress.DBTable); query.BuildPropertyParam(nameof(MessageAddress.UserId), CompareType.Equal, GuiEnvironment.User?.Id); query.BuildPropertyParam(nameof(MessageAddress.DateRead), CompareType.Is, DBNull.Value); MessageAddress.DBTable.Load(query, DBLoadParam.Synchronize, null).LastOrDefault(); }
private void ToolReportClick(object sender, EventArgs e) { if (dataTree.SelectedDBItem is DBTable) { var query = new QQuery { Table = (DBTable)dataTree.SelectedDBItem }; var projecth = new ProjectHandler { Project = query }; GuiService.Main.CurrentProject = projecth; } }
public IEnumerable <T> LoadByStamp(QQuery query, DBTransaction transaction = null) { if (items.Count == 0) { return(Load(query)); } query.Columns.Clear(); query.Columns.Add(new QColumn(PrimaryKey)); query.Columns.Add(new QColumn(StampKey)); return(Load(query.ToCommand(), DBLoadParam.Synchronize, transaction)); }
public Task <IEnumerable <T> > LoadAsync(QQuery query, DBLoadParam param = DBLoadParam.None, DBTransaction transaction = null) { return(Task.Run <IEnumerable <T> >(() => { try { return Load(query, param, transaction); } catch (Exception e) { Helper.OnException(e); return null; } })); }
public static void LoadDocuments(User user) { var qWork = new QQuery(string.Empty, DocumentWork.DBTable); qWork.Columns.Add(new QColumn(nameof(DocumentWork.Document))); qWork.BuildPropertyParam(nameof(DocumentWork.IsComplete), CompareType.Equal, false); qWork.BuildPropertyParam(nameof(DocumentWork.UserId), CompareType.Equal, user); var qDocs = new QQuery(string.Empty, Document.DBTable); qDocs.BuildPropertyParam(nameof(Document.Id), CompareType.In, qWork); Document.DBTable.Load(qDocs, DBLoadParam.Synchronize); DocumentWork.DBTable.Load(qWork, DBLoadParam.Synchronize); }
public static async Task <User> GetUser(string login, string passoword) { var query = new QQuery(string.Empty, User.DBTable); query.BuildPropertyParam(nameof(Login), CompareType.Equal, login); query.BuildPropertyParam(nameof(Password), CompareType.Equal, passoword); var user = User.DBTable.Select(query).FirstOrDefault(); if (user != null) { await UserReg.LogUser(user, UserRegType.Authorization, "GetUser"); } return(user); }
public IList <ElementType> Query <ElementType>(Transaction trans, Type extent, IComparer <ElementType> comparer) { lock (Lock()) { trans = CheckTransaction(trans); QQuery query = (QQuery)Query(trans); query.Constrain(extent); if (null != comparer) { query.SortBy(new GenericComparerAdaptor <ElementType>(comparer)); } IQueryResult queryResult = query.GetQueryResult(); return(new GenericObjectSetFacade <ElementType>(queryResult)); } }
public DBTableView(DBTable <T> table, QParam defaultFilter, DBViewKeys mode = DBViewKeys.None, DBStatus statusFilter = DBStatus.Empty) { propertyHandler = null; this.table = table; FilterQuery = new Query <T>(); Query = new QQuery(); TypeFilter = typeof(T); DefaultParam = defaultFilter; StatusFilter = statusFilter; keys = mode; table.AddView(this); if ((keys & DBViewKeys.Empty) != DBViewKeys.Empty) { UpdateFilter(); } }
public PersoneIdentify FindByCustomer(object customer) { if (customer == null) { return(null); } var filter = new QQuery("", PersoneIdentify.DBTable); filter.BuildPropertyParam(nameof(PersoneIdentify.PersoneId), CompareType.Equal, customer); var list = ((IEnumerable <PersoneIdentify>)table.LoadItems(filter, DBLoadParam.Load)).ToList(); if (list.Count > 1) { list.Sort(new DBComparer <PersoneIdentify, int?>(Table.PrimaryKey, ListSortDirection.Descending)); } return(list.Count == 0 ? null : list[0] as PersoneIdentify); }
private void ToolCreateClick(object sender, EventArgs e) { if (Table == null) { return; } //if (DataEnvir.Items.Queries.Contains (toolExpName.Text)) { // MessageBox.Show ("Запрос с данным кодом уже имеется!"); // return; //} Table = Table; Query = new QQuery { Table = Table }; //DataEnvir.Items.Queries.Add (expression); }
public async Task <object> Execute(ExecuteArgs parameters) { var filter = new QQuery(string.Empty, DocumentWork.DBTable); filter.BuildPropertyParam(nameof(DocumentWork.IsComplete), CompareType.Equal, false); filter.BuildPropertyParam(nameof(DocumentWork.IsSystem), CompareType.Equal, true); //string filter = string.Format("{0}!='{1}' and {2} in (select {3} from {4} where {5} = '{6}')", foreach (DocumentWork work in DocumentWork.DBTable.Load(filter, DBLoadParam.Load | DBLoadParam.Synchronize, parameters.Transaction)) { if (work.Stage == null || work.Document == null) { continue; } work.Document.ExecuteProceduresByWork(work, StageParamProcudureType.Manual, parameters.Transaction); await work.Document.Save(parameters.Transaction); } return(null); }
public IEnumerable <T> Select(QQuery query, IEnumerable <T> list = null) { IEnumerable <T> buf = null; if (query.Parameters.Count == 0) { buf = list ?? this; } else if (query.Parameters.Count == 1) { buf = Select(query.Parameters[0], list); } else { buf = Select(query.Parameters, list); } return(buf); }
private void LoadTable(DBTable table) { rows.Clear(); wait.Reset(); string filter = table.GetStatusParam(DBStatus.New | DBStatus.Edit | DBStatus.Delete).Format(); if (!wait.WaitOne(0)) { foreach (DBItem row in table.LoadItems("where " + filter)) { if (wait.WaitOne(0)) { break; } if (rows.Find("Row", CompareType.Equal, row) == null) { try { rows.Add(new LogMap(row)); } catch { } } } } using (QQuery qdelete = new QQuery("", (DBTable)table.LogTable)) { qdelete.BuildParam(table.LogTable.ElementTypeKey, CompareType.Equal, DBLogType.Delete); qdelete.BuildParam(table.LogTable.StatusKey, CompareType.Equal, DBStatus.New); foreach (DBLogItem log in table.LogTable.LoadItems(qdelete, DBLoadParam.Synchronize)) { LogMap change = new LogMap { Table = table }; //change.Logs.Add(log); change.RefreshChanges(); rows.Add(change); } } //wait.Set(); rows.OnCollectionChanged(NotifyCollectionChangedAction.Reset); }
public IEnumerable <T> LoadCache(string filter, DBLoadParam loadParam = DBLoadParam.Referencing, DBTransaction transaction = null) { if (!queryChache.TryGetValue(filter, out var query)) { query = new QQuery(filter, this); Load(query, loadParam, transaction); queryChache.TryAdd(filter, query); } if (TypeHelper.IsInterface(typeof(T), typeof(IGroup))) { var temp = Select(query).ToList(); ListHelper.QuickSort(temp, TreeComparer <IGroup> .Default); return(temp); } else { return(Select(query)); } }
public static QParam CreateRefsParam(object id) { var qrefing = new QQuery(string.Format("select {0} from {1} where {2} = {3}", DocumentReference.DBTable.ParseProperty(nameof(DocumentReference.DocumentId)).Name, DocumentReference.DBTable.Name, DocumentReference.DBTable.ParseProperty(nameof(DocumentReference.ReferenceId)).Name, id)); var qrefed = new QQuery(string.Format("select {2} from {1} where {0} = {3}", DocumentReference.DBTable.ParseProperty(nameof(DocumentReference.DocumentId)).Name, DocumentReference.DBTable.Name, DocumentReference.DBTable.ParseProperty(nameof(DocumentReference.ReferenceId)).Name, id)); var param = new QParam(); param.Parameters.Add(new QParam(LogicType.And, DBTable.PrimaryKey, CompareType.In, qrefed)); param.Parameters.Add(new QParam(LogicType.Or, DBTable.PrimaryKey, CompareType.In, qrefing)); return(param); }
private void CheckDelete(QQuery filter, IEnumerable <T> buf, DBLoadParam param, DBTransaction transaction) { var list = Select(filter).ToList(); var bufList = buf.ToList(); if (list.Count > bufList.Count) { foreach (var item in list) { if ((item.UpdateState & DBUpdateState.Insert) != DBUpdateState.Insert && !bufList.Contains(item)) { if (transaction.View != null && transaction.View.IsStatic) { transaction.View.Remove(item); } Remove(item); } } } }
public static async Task <Instance> GetByNetId(IPEndPoint endPoint, bool create, IUserIdentity user = null) { var query = new QQuery(DBTable); query.BuildPropertyParam(nameof(Host), CompareType.Equal, endPoint.Address.ToString()); query.BuildPropertyParam(nameof(Port), CompareType.Equal, endPoint.Port); query.BuildPropertyParam(nameof(Action), CompareType.Equal, false); var instance = DBTable.Load(query).LastOrDefault(); if (instance == null && create) { instance = new Instance { EndPoint = endPoint, Active = true, IsCurrent = true }; await instance.Save(user); } return(instance); }
public IEnumerable <T> Load(QQuery query, DBLoadParam param = DBLoadParam.None, DBTransaction transaction = null) { if (query.Table != this) { throw new ArgumentException(nameof(query)); } if (Count == 0) { param &= ~DBLoadParam.CheckDeleted; } var buf = Load(query.ToCommand(true), param, transaction); if (buf != null && (param & DBLoadParam.CheckDeleted) == DBLoadParam.CheckDeleted) { CheckDelete(query, buf, param, transaction); } if (query.Parameters.Count == 0) { IsSynchronized = true; } return(buf); }
protected override IEnumerable ListFind(string filter) { IEnumerable list = null; if (Table.CodeKey != null) { DBItem item = Table.LoadItemByCode(filter.Trim(), Table.CodeKey, Table.IsSynchronized ? DBLoadParam.None : DBLoadParam.Load | DBLoadParam.Synchronize); if (item != null) { list = new object[] { item } } ; } if (list == null) { var query = new QQuery("", Table); query.SimpleFilter(EntryText); TableEditor.Loader.LoadAsync(query); list = query.Select(); } return(list); }
public string FormatValue(QItem Value, IDbCommand command = null) { if (Value == null) { return(string.Empty); } if (Value is QQuery && ((QQuery)Value).Table != null) { QQuery squery = (QQuery)Value; if (squery.Columns.Count == 0) { squery.Columns.Add(new QColumn(squery.Table.PrimaryKey)); } return("(" + squery.Format(command) + ")"); } else if (Value is QExpression) { return("(" + Value.Format(command) + ")"); } else { return(Value.Format(command)); } }
/// <param name="q"></param> public virtual void LoadFromQuery(QQuery q) { throw new NotImplementedException(); }
public _IEnumerable_28(QQuery query) { this.query = query; }
public override void LoadFromQuery(QQuery query) { _iterable = new _IEnumerable_28(query); }
public QLinRoot(IQuery query, Type clazz) { _query = (QQuery)query; query.Constrain(clazz); QLinSupport.Context(clazz); }
public _IClosure4_35(MQueryExecute _enclosing, QQuery query) { this._enclosing = _enclosing; this.query = query; }
private AbstractQueryResult ExecuteFully(QQuery query) { return((AbstractQueryResult)query.TriggeringQueryEvents(new _IClosure4_35(this, query))); }