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);
}
