public T LoadByCode(string code, DBLoadParam param = DBLoadParam.None) { if (CodeKey == null) { return(null); } return(LoadByCode(code, CodeKey, param)); }
public IEnumerable <DBGroupItem> GetSubGroups(DBLoadParam param) { if (PrimaryId == null) { return(new List <DBGroupItem>(0)); } return(GetReferencing(Table, Table.GroupKey, param).Cast <DBGroupItem>()); }
public IEnumerable <T> GetSubGroups <T>(DBLoadParam param) where T : DBGroupItem, new() { if (PrimaryId == null) { return(new List <T>(0)); } return(GetReferencing <T>((DBTable <T>)Table, Table.GroupKey, param)); }
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, DBLoadParam.Referencing, transaction); queryChache.TryAdd(filter, query); } return(Select(query)); }
public IEnumerable <T> Load(DBLoadParam param = DBLoadParam.None) { using (var transaction = new DBTransaction(Table.Connection, null, true) { View = this }) { return(table.Load(Query, param, transaction)); } }
public async void LoadAsynch(DBLoadParam param = DBLoadParam.None) { using (var transaction = new DBTransaction(Table.Connection, null, true) { View = this }) { var items = await table.LoadAsync(Query, param, transaction).ConfigureAwait(false); } }
public T LoadByCode(string code, DBColumn column, DBLoadParam param, DBTransaction transaction = null) { var row = SelectOne(column, code); if (row == null && (param & DBLoadParam.Load) == DBLoadParam.Load)//&& !IsSynchronized { var command = System.CreateCommand(Schema.Connection, CreateQuery($"where a.{column.Name}={Schema.System.ParameterPrefix}{column.Name}", "a", Columns)); System.CreateParameter(command, Schema.System.ParameterPrefix + column.Name, code, column); row = Load(command, param, transaction).FirstOrDefault(); } return(row); }
public Task <IEnumerable <T> > LoadAsync(string query, DBLoadParam param = DBLoadParam.None, IEnumerable <DBColumn> columns = null, DBTransaction transaction = null) { return(Task.Run <IEnumerable <T> >(() => { try { return Load(query, param, columns, transaction); } catch (Exception e) { Helper.OnException(e); return null; } })); }
public IEnumerable <T> Load(string whereText = null, DBLoadParam param = DBLoadParam.None, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { if (string.IsNullOrEmpty(whereText) || whereText.Trim().Equals("where", StringComparison.OrdinalIgnoreCase)) { whereText = string.Empty; } else if (whereText.Length > 3 && whereText.IndexOf("where", StringComparison.OrdinalIgnoreCase) < 0 && !whereText.Trim().StartsWith("select", StringComparison.OrdinalIgnoreCase)) { whereText = "where " + whereText; } return(Load(Schema.Connection.CreateCommand(CreateQuery(whereText, "a", cols)), param, transaction)); }
public Task <IEnumerable <T> > LoadAsync(IDbCommand command, DBLoadParam param = DBLoadParam.None, DBTransaction transaction = null) { return(Task.Run <IEnumerable <T> >(() => { try { return Load(command, param, transaction); } catch (Exception e) { Helper.OnException(e); return null; } })); }
public T LoadById(object id, DBLoadParam param = DBLoadParam.Load, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { object val = PrimaryKey?.ParseValue(id); if (val == null || PrimaryKey == null) { return(null); } T row = SelectOne(PrimaryKey, val) as T; if (row == null && (param & DBLoadParam.Load) == DBLoadParam.Load) { row = LoadItem(val, param, cols, transaction); } return(row); }
public async ValueTask <T> LoadByKeyAsync(object key, DBColumn column, DBLoadParam param = DBLoadParam.Load, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { object val = column?.ParseValue(key); if (val == null || column == null) { return(null); } T row = SelectOne(column, key) as T; if (row == null && (param & DBLoadParam.Load) == DBLoadParam.Load) { row = await LoadItemAsync(val, column, param, cols, transaction); } return(row); }
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 async ValueTask <IEnumerable <T> > LoadCacheAsync(string filter, DBLoadParam loadParam = DBLoadParam.Referencing, DBTransaction transaction = null) { if (!ParseQuery(filter, out var query)) { await LoadAsync(query, loadParam, transaction); } var result = Select(query); if (TypeHelper.IsInterface(typeof(T), typeof(IGroup))) { var temp = result.ToList(); ListHelper.QuickSort(temp, TreeComparer <IGroup> .Default); return(temp); } else { return(result); } }
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 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); }
public T LoadById(object id, DBLoadParam param = DBLoadParam.Load, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { return(LoadByKey(id, PrimaryKey, param, cols, transaction)); }
public ValueTask <T> LoadByIdAsync(object id, DBLoadParam param = DBLoadParam.Load, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { return(LoadByKeyAsync(id, PrimaryKey, param, cols, transaction)); }
IEnumerable <DBItem> IDBTableView.Load(DBLoadParam param) { return(Load(param)); }
public override IEnumerable <DBItem> LoadItems(string whereText = null, DBLoadParam param = DBLoadParam.None, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { return(Load(whereText, param, cols, transaction)); }
public override IEnumerable <DBItem> LoadItems(QQuery query, DBLoadParam param = DBLoadParam.None, DBTransaction transaction = null) { return(Load(query, param, transaction)); }
public override void ReloadItem(object id, DBLoadParam param = DBLoadParam.Load, DBTransaction transaction = null) { LoadItem(id, param); }
public T LoadByCode(string code, string column, DBLoadParam param = DBLoadParam.None) { return(LoadByCode(code, ParseColumn(column), param)); }
public override IEnumerable <DBItem> LoadItems(IDbCommand command, DBLoadParam param = DBLoadParam.None, DBTransaction transaction = null) { return(Load(command, param, transaction)); }
public T1 LoadById <T1>(object id, DBLoadParam param = DBLoadParam.Load, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) where T1 : T { return((T1)LoadById(id, param, cols)); }
public override DBItem LoadItemById(object id, DBLoadParam param = DBLoadParam.Load, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { return(LoadById(id, param, cols, transaction)); }
public async Task <T> LoadItemAsync(object id, DBColumn column, DBLoadParam param = DBLoadParam.Load, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { return((await LoadAsync(CreateKeyCommmand(id, column, cols), param, transaction)).FirstOrDefault()); }
public override DBItem LoadItemByCode(string code, DBColumn column, DBLoadParam param, DBTransaction transaction = null) { return(LoadByCode(code, column, param)); }
public T LoadItem(object id, DBLoadParam param = DBLoadParam.Load, IEnumerable <DBColumn> cols = null, DBTransaction transaction = null) { return(Load(CreateItemCommmand(id, cols), param, transaction).FirstOrDefault()); }
public List <T> Load(IDbCommand command, DBLoadParam param = DBLoadParam.None, DBTransaction baseTransaction = null) { var list = new List <T>(); var transaction = baseTransaction ?? new DBTransaction(Connection, null, true); try { transaction.AddCommand(command); if ((param & DBLoadParam.Reference) == DBLoadParam.Reference) { LoadReferenceBlock(command, transaction); } if ((param & DBLoadParam.Referencing) == DBLoadParam.Referencing) { LoadReferencingBlock(command, transaction); } if (transaction.Canceled) { return(list); } var whereInd = command.CommandText.IndexOf("where ", StringComparison.OrdinalIgnoreCase); var arg = new DBLoadProgressEventArgs(transaction.View, 0, 0, null); if (transaction.View != null && transaction.View.Table == this && transaction.View.IsStatic) { transaction.View.Clear(); } if ((transaction.ReaderParam & DBLoadParam.GetCount) == DBLoadParam.GetCount) { string w = whereInd == -1 ? string.Empty : command.CommandText.Substring(whereInd); var val = transaction.ExecuteQuery(transaction.AddCommand(DBCommand.CloneCommand(command, BuildQuery(w, "a", null, "count(*)"))), DBExecuteType.Scalar); arg.TotalCount = val is Exception ? -1 : int.Parse(val.ToString()); if (arg.TotalCount < 0 || arg.TotalCount == 0) { return(list); } if (items.Capacity < arg.TotalCount) { items.Capacity = arg.TotalCount; } //arg.TotalCount = Rows._items.Capacity; } //var buffer = new List<T>(arg.TotalCount == 0 ? 1 : arg.TotalCount); if (transaction.Canceled) { return(list); } using (transaction.Reader = transaction.ExecuteQuery(command, DBExecuteType.Reader) as IDataReader) { CheckColumns(transaction); while (!transaction.Canceled && transaction.Reader.Read()) { T row = null; lock (Lock) { row = LoadFromReader(transaction); if (!row.Attached && (transaction.ReaderParam & DBLoadParam.NoAttach) != DBLoadParam.NoAttach) { Add(row); } } if (arg.TotalCount > 0) { arg.Current++; arg.CurrentRow = row; RaiseLoadProgress(arg); } list.Add(row); if (transaction.View?.Table == this && transaction.View.IsStatic) { transaction.View.Add(row); } } } transaction.Reader = null; //Check IsSynchronized if (transaction.View?.Table == this) { transaction.View.IsSynchronized = true; } if (whereInd < 0) { IsSynchronized = true; } //return buffer; } finally { transaction.Reader = null; RaiseLoadCompleate(transaction); if (baseTransaction == null) { transaction.Dispose(); } } return(list); }