public QBetween(object val1 = null, object val2 = null, DBColumn column = null)
{
if (val1 is QItem)
{
value1 = (QItem)val1;
}
else if (val1 is DBColumn)
{
value1 = new QColumn((DBColumn)val1);
}
else if (val1 != null)
{
value1 = new QValue(val1, column);
}
if (val2 is QItem)
{
value2 = (QItem)val1;
}
else if (val2 is DBColumn)
{
value2 = new QColumn((DBColumn)val2);
}
else if (val2 != null)
{
value2 = new QValue(val2, column);
}
}
public void OnItemChanged(DBItem item, string propertyName, DBColumn column)
{
if (item is T titem)
{
OnItemChanged(titem, propertyName, column);
}
}
public void CheckViews(DBItem item, string property, DBColumn column)
{
for (int i = 0; i < queryViews.Count; i++)
{
queryViews[i].OnItemChanged(item, property, column);
}
}
public override object ReadValue(DBColumn column, object value)
{
if (value == DBNull.Value)
{
return(null);
}
var from = value.GetType();
if (from != column.DataType)
{
var temp = column.DataType;
if (temp.IsEnum)
{
temp = temp.GetEnumUnderlyingType();
if (from == temp)
{
return(value);
}
}
else if (from == typeof(short))
{
if (temp == typeof(byte))
{
value = (byte)(short)value;
}
else
{
throw new InvalidCastException($"From {from} to {temp}");
}
}
}
return(value);
}
public DBColumn Add(string name, DBTable reference)
{
DBColumn column = Add(name, reference.PrimaryKey.DataType, reference.PrimaryKey.Size);
column.ReferenceTable = reference;
return(column);
}
public DBColumn ParseColumn(string name, DBSchema schema = null)
{
if (string.IsNullOrEmpty(name))
{
return(null);
}
DBColumn column = null;
DBTable table = ParseTable(name, schema);
int index = name.LastIndexOf('.');
name = index < 0 ? name : name.Substring(index + 1);
if (schema == null)
{
schema = DefaultSchema;
}
if (table != null)
{
column = table.ParseColumn(name);
}
else if (schema != null)
{
foreach (var t in schema.Tables)
{
column = t.Columns[name];
if (column != null)
{
break;
}
}
}
return(column);
}
public static QItem Fabric(object value, DBColumn column)
{
if (value is QItem)
{
return((QItem)value);
}
else if (value is DBColumn)
{
return(new QColumn((DBColumn)value));
}
else if (value is DateInterval)
{
if (((DateInterval)value).IsEqual())
{
return(new QBetween(((DateInterval)value).Min.Date, ((DateInterval)value).Min.Date.AddDays(1), column));
}
else
{
return(new QBetween(((DateInterval)value).Min, ((DateInterval)value).Max, column));
}
}
else if (value is IList)
{
return(new QEnum((IList)value, column));
}
else
{
return(new QValue(value, column));
}
}
public DBItemEventArgs(DBItem item, DBColumn column = null, string property = null, object value = null)
{
Item = item;
State = item.UpdateState;
Column = column;
Value = value;
Property = property ?? string.Empty;
}
public override void AddIndex(DBColumn column, object value)
{
if (column.Table != main.Table)
{
column = ((DBVirtualColumn)column).BaseColumn;
}
main.AddIndex(column, value);
}
public override void FormatAlter(StringBuilder ddl, DBColumn column)
{
ddl.AppendLine($"alter table {column.Table.SqlName} alter column {column.SqlName} TYPE {FormatType(column)};");
if (column.IsNotNull || column.IsPrimaryKey)
{
ddl.AppendLine($"alter table {column.Table.SqlName} alter column {column.SqlName} SET not null;");
}
}
public DBColumn ParseLogProperty(string name, ref DBColumn column)
{
if (column != DBColumn.EmptyKey)
{
return(column);
}
return(column = BaseTable?.ParseProperty(name)?.LogColumn);
}
public override void OnItemChanging(DBItem item, string property, DBColumn column, object value)
{
column?.Index?.Remove((object)item, value);
foreach (var table in virtualTables)
{
table.OnItemChanging(item, property, column, value);
}
}
public override void OnItemChanging <V>(DBItem item, string property, DBColumn column, V value)
{
column?.Index?.Remove <T, V>((T)item, value);
foreach (var table in virtualTables)
{
table.OnItemChanging <V>(item, property, column, value);
}
}
public override void RemoveIndex(DBColumn column, object value)
{
//base.RemoveIndex(column, value);
if (column.Table != main.Table)
{
column = ((DBVirtualColumn)column).BaseColumn;
}
main.RemoveIndex(column, value);
}
public DBComparer(DBTable table, DBColumn column, string proeprty, ListSortDirection direction = ListSortDirection.Ascending)
{
Table = table;
PropertyName = proeprty;
Direction = direction;
property = column;
buffered = property != null && property.Name == PropertyName;
refernce = property != null && property.IsReference;
}
public T SelectOne(DBColumn column, object val)
{
var value = column.ParseValue(val);
if (column.Index != null)
{
return(column.Index.SelectOne <T>(value));
}
return(Select(column, CompareType.Equal, value).FirstOrDefault());
}
public static PullIndex Create(DBTable list, DBColumn column)
{
if (column.DataType == null)
{
throw new ArgumentException($"Type is null on column {column.FullName}");
}
//Type gtype = typeof(DBNullablePullIndex<>).MakeGenericType(column.DataType);
return(PullIndexFabric.Create(column.Pull, list.ItemType.Type, column.DataType, list.DefaultComparer));
}
public IEnumerable <T> Search(DBColumn column, CompareType comparer, object value, IEnumerable <T> list)
{
list = list ?? this;
foreach (T row in list)
{
if (CheckItem(row, row.GetValue(column), value, comparer))
{
yield return(row);
}
}
}
public DBForeignKey GetByColumns(DBColumn column, DBColumn reference)
{
foreach (var item in items)
{
if (item.Column == column && item.Reference == reference)
{
return(item);
}
}
return(null);
}
public bool Remove(DBColumn column)
{
var refernce = Get(column);
if (refernce != null)
{
Remove(refernce);
return(true);
}
return(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 object Optimisation(DBColumn column, CompareType comparer, object value)
{
if (value == null)
{
return(value);
}
if (value is QQuery)
{
if (column.IsPrimaryKey)
{
var query = (QQuery)value;
if (query.Columns[0] is QColumn qcolumn && !query.IsRefence)
{
var buf = new List <T>();
foreach (DBItem item in query.Select())
{
var reference = item.GetReference <T>(qcolumn.Column, DBLoadParam.None);
//if (reference != null && reference.Table != this)
//{
// throw new Exception(string.Format("Value {0} Table {1}", reference.Table, this));
//}
if (reference != null)
{
var index = buf.BinarySearch(reference);
if (index < 0)
{
buf.Insert(-index - 1, reference);
}
}
}
value = buf;
}
}
else
{
value = SelectQuery(null, (QQuery)value, comparer);
}
}
else if (value.GetType() == typeof(QEnum))
{
value = ((QEnum)value).Items;
}
else if (comparer.Type == CompareTypes.In && value is string)
{
value = value.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
}
else if (comparer.Type == CompareTypes.Like)
{
value = Helper.BuildLike(value == null ? string.Empty : value.ToString());
}
return(value);
}
public bool GroupCompare(string column, string value)
{
DBColumn col = Table.Columns[column];
foreach (DBItem item in GroupHelper.GetAllParent <DBGroupItem>(this))
{
if (!item[col].ToString().Equals(value, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
}
return(true);
}
public DBColumn Add(string name, Type t, int size)
{
if (Contains(name))
{
return(this[name]);
}
var column = new DBColumn(name, t, size)
{
Table = Table
};
Add((T)column);
return(column);
}
public QEnum(IList list, DBColumn column = null) : this()
{
foreach (var item in list)
{
if (item is QItem)
{
items.Add((QItem)item);
}
else
{
items.Add(QParam.Fabric(item, column));
}
}
}
public override void OnItemChanged(DBItem item, string property, DBColumn column, object value)
{
if (string.Equals(property, nameof(DBItem.Attached), StringComparison.Ordinal) ||
string.Equals(property, nameof(DBItem.UpdateState), StringComparison.Ordinal))
{
return;
}
column?.Index?.Add((object)item, value);
foreach (var table in virtualTables)
{
table.OnItemChanged(item, property, column, value);
}
CheckViews(item, property, column);
}
//private string property;
public SortIndex(DBTable list, string property)
{
this.row = list.NewItem(DBUpdateState.Default);
this.list = list;
//this.property = property;
if (list.Columns.Contains(property))
{
column = list.Columns[property];
comparer = column.CreateComparer(ListSortDirection.Ascending);
}
else
{
comparer = new InvokerComparer(typeof(DBItem), property, ListSortDirection.Ascending);
}
Refresh();
}
public override string FormatQColumn(DBColumn column, string tableAlias)
{
if (column.ColumnType == DBColumnTypes.Internal ||
column.ColumnType == DBColumnTypes.Expression ||
column.ColumnType == DBColumnTypes.Code)
{
return(string.Empty);
}
else if (column.ColumnType == DBColumnTypes.Query && column.Table.Type != DBTableType.View)
{
return(base.FormatQColumn(column, tableAlias));
}
else
{
return($"{tableAlias}{(tableAlias != null ? "." : string.Empty)}[{column.SqlName}]");
}
}
public override void OnItemChanged(DBItem item, string property, DBColumn column, object value)
{
if (property == nameof(DBItem.Attached) || property == nameof(DBItem.UpdateState))
{
return;
}
if (column?.Index != null)
{
column.Index.Add(item, value);
}
foreach (var table in virtualTables)
{
table.OnItemChanged(item, property, column, value);
}
CheckViews(item, property, column);
}
public static void Read(BinaryReader br, DBItem row, Dictionary <int, string> map)
{
while (true)
{
DBRowBinarySeparator separator = PeekSeparator(br);
if (separator != DBRowBinarySeparator.RowStart &&
separator != DBRowBinarySeparator.None)
{
break;
}
int column = br.ReadInt32();
object value = Helper.ReadBinary(br);
DBColumn dbColumn = row.Table.ParseColumn(map[column]);
row.SetValue(value, dbColumn, false);
}
row.Accept((IUserIdentity)null);
}
