| private GetRecordFromVersion ( DataRowVersion version ) : int | ||
| version | DataRowVersion | |
| Результат | int | |
internal override object Eval(DataRow row, DataRowVersion version)
{
if (!found)
{
#if DEBUG
if (CompModSwitches.NameNode.TraceVerbose)
{
Debug.WriteLine("Can not find column " + name);
}
#endif
throw ExprException.UnboundName(name);
}
if (row == null)
{
if (IsTableConstant()) // this column is TableConstant Aggregate Function
{
return(column.DataExpression.Evaluate());
}
else
{
#if DEBUG
if (CompModSwitches.NameNode.TraceVerbose)
{
Debug.WriteLine("Can not eval column without a row.." + name);
}
#endif
throw ExprException.UnboundName(name);
}
}
return(column[row.GetRecordFromVersion(version)]);
}
internal override object Eval(DataRow row, DataRowVersion version)
{
if (!this.found)
{
throw ExprException.UnboundName(this.name);
}
if (row != null)
{
return(this.column[row.GetRecordFromVersion(version)]);
}
if (!this.IsTableConstant())
{
throw ExprException.UnboundName(this.name);
}
return(this.column.DataExpression.Evaluate());
}
internal override object Eval(DataRow row, DataRowVersion version)
{
if (!found)
{
throw ExprException.UnboundName(name);
}
if (row == null)
{
if (IsTableConstant()) // this column is TableConstant Aggregate Function
{
return(column.DataExpression.Evaluate());
}
else
{
throw ExprException.UnboundName(name);
}
}
return(column[row.GetRecordFromVersion(version)]);
}
internal override object Eval(DataRow row, DataRowVersion version) {
if (!found) {
throw ExprException.UnboundName(name);
}
if (row == null) {
if(IsTableConstant()) // this column is TableConstant Aggregate Function
return column.DataExpression.Evaluate();
else {
throw ExprException.UnboundName(name);
}
}
return column[row.GetRecordFromVersion(version)];
}
internal void SilentlySetValue(DataRow dr, DataColumn dc, DataRowVersion version, object newValue) {
// get record for version
int record = dr.GetRecordFromVersion(version);
bool equalValues = false;
if (DataStorage.IsTypeCustomType(dc.DataType) && newValue != dc[record]) {
// if UDT storage, need to check if reference changed. See bug 385182
equalValues = false;
}
else {
equalValues = dc.CompareValueTo(record, newValue, true);
}
// if expression has changed
if (!equalValues) {
int[] oldIndex = dr.Table.RemoveRecordFromIndexes(dr, version);// conditional, if it exists it will try to remove with no event fired
dc.SetValue(record, newValue);
int[] newIndex = dr.Table.InsertRecordToIndexes(dr, version);// conditional, it will insert if it qualifies, no event will be fired
if (dr.HasVersion(version)) {
if (version != DataRowVersion.Original) {
dr.Table.RecordChanged(oldIndex, newIndex);
}
if (dc.dependentColumns != null) {
//BugBug - passing in null for cachedRows. This means expression columns as keys does not work when key changes.
dc.Table.EvaluateDependentExpressions(dc.dependentColumns, dr, version, null);
}
}
}
dr.ResetLastChangedColumn();
}
// InsertRecordToIndexes inserts the given record (using row and version) to all indexes and it stores and returns the position of inserted
// record to each index
// IT SHOULD NOT CAUSE ANY EVENT TO BE FIRED
internal int[] InsertRecordToIndexes(DataRow row, DataRowVersion version) {
int indexCount = LiveIndexes.Count;
int [] positionIndexes = new int[indexCount];
int recordNo = row.GetRecordFromVersion(version);
DataViewRowState states = row.GetRecordState(recordNo);
while (--indexCount >= 0) {
if (row.HasVersion(version)) {
if ((states & indexes[indexCount].RecordStates) != DataViewRowState.None) {
positionIndexes [indexCount] = indexes[indexCount].InsertRecordToIndex(recordNo);
}
else {
positionIndexes [indexCount] = -1;
}
}
}
return positionIndexes;
}
// RemoveRecordFromIndexes removes the given record (using row and version) from all indexes and it stores and returns the position of deleted
// record from each index
// IT SHOULD NOT CAUSE ANY EVENT TO BE FIRED
internal int[] RemoveRecordFromIndexes(DataRow row, DataRowVersion version) {
int indexCount = LiveIndexes.Count;
int [] positionIndexes = new int[indexCount];
int recordNo = row.GetRecordFromVersion(version);
DataViewRowState states = row.GetRecordState(recordNo);
while (--indexCount >= 0) {
if (row.HasVersion(version) && ((states & indexes[indexCount].RecordStates) != DataViewRowState.None)) {
int index = indexes[indexCount].GetIndex(recordNo);
if (index > -1) {
positionIndexes [indexCount] = index;
indexes[indexCount].DeleteRecordFromIndex(index); // this will delete the record from index and MUSt not fire event
}
else {
positionIndexes [indexCount] = -1; // this means record was not in index
}
}
else {
positionIndexes [indexCount] = -1; // this means record was not in index
}
}
return positionIndexes;
}
internal override object Eval(DataRow row, DataRowVersion version)
{
if (!this.found)
{
throw ExprException.UnboundName(this.name);
}
if (row != null)
{
return this.column[row.GetRecordFromVersion(version)];
}
if (!this.IsTableConstant())
{
throw ExprException.UnboundName(this.name);
}
return this.column.DataExpression.Evaluate();
}
// Return the field value as a string. If the field value is NULL, then NULL is return.
// If the column type is string and it's value is empty, then the empty string is returned.
// If the column type is not string, or the column type is string and the value is not empty string, then a non-empty string is returned
// This method does not throw any formatting exceptions, since we can always format the field value to a string.
internal string GetColumnValueAsString(DataRow row, DataRowVersion version)
{
object objValue = this[row.GetRecordFromVersion(version)];
if (DataStorage.IsObjectNull(objValue))
{
return null;
}
string value = ConvertObjectToXml(objValue);
Debug.Assert(value != null);
return value;
}
internal virtual void Evaluate(DataRow row, DataRowVersion version)
{
#if DEBUG
if (CompModSwitches.DataExpression.TraceVerbose)
{
Debug.WriteLine("Evaluate expression column Queue, version = " + version.ToString() + " for table " + owner.TableName);
}
#endif
Debug.Assert(columns != null, "Invalid dependensy list");
Debug.Assert(row != null, "Invalid argument to Evaluate, row");
for (int i = 0; i < columnCount; i++)
{
DataColumn col = columns[i];
Debug.Assert(col.Computed, "Only computed columns should be in the queue.");
#if DEBUG
if (CompModSwitches.DataExpression.TraceVerbose)
{
Debug.WriteLine("Evaluate column " + col.ColumnName + " = " + col.DataExpression.ToString());
}
#endif
if (col.Table == null)
{
continue;
}
if (col.Table != owner)
{
// first if the column belongs to an other table we need to recalc it for each row in the foreing table
#if DEBUG
if (CompModSwitches.DataExpression.TraceVerbose)
{
Debug.WriteLine("the column belong to a different table %%%%%%%");
}
#endif
// we need to update all foreign table - NOPE, only those who are valid parents. ALTHOUGH we're skipping old parents right now... confirm.
DataRowVersion foreignVer = (version == DataRowVersion.Proposed) ? DataRowVersion.Default : version;
int parentRelationCount = owner.ParentRelations.Count;
for (int j = 0; j < parentRelationCount; j++)
{
DataRelation relation = owner.ParentRelations[j];
if (relation.ParentTable != col.Table)
{
continue;
}
DataRow parentRow = row.GetParentRow(relation, version);
if (parentRow != null)
{
col[parentRow.GetRecordFromVersion(foreignVer)] = col.DataExpression.Evaluate(parentRow, foreignVer);
}
}
int childRelationCount = owner.ChildRelations.Count;
for (int j = 0; j < childRelationCount; j++)
{
DataRelation relation = owner.ChildRelations[j];
if (relation.ChildTable != col.Table)
{
continue;
}
DataRow[] childRows = row.GetChildRows(relation, version);
for (int k = 0; k < childRows.Length; k++)
{
if (childRows[k] != null)
{
col[childRows[k].GetRecordFromVersion(foreignVer)] = col.DataExpression.Evaluate(childRows[k], foreignVer);
}
}
}
}
else if (col.DataExpression.HasLocalAggregate())
{
// if column expression references a local Table aggregate we need to recalc it for the each row in the local table
DataRowVersion aggVersion = (version == DataRowVersion.Proposed) ? DataRowVersion.Default : version;
#if DEBUG
if (CompModSwitches.DataExpression.TraceVerbose)
{
Debug.WriteLine("it has local aggregate.");
}
#endif
bool isConst = col.DataExpression.IsTableAggregate();
object val = null;
if (isConst)
{
val = col.DataExpression.Evaluate(row, aggVersion);
}
DataRow[] rows = new DataRow[col.Table.Rows.Count];
col.Table.Rows.CopyTo(rows, 0);
for (int j = 0; j < rows.Length; j++)
{
if (!isConst)
{
val = col.DataExpression.Evaluate(rows[j], aggVersion);
}
col[rows[j].GetRecordFromVersion(aggVersion)] = val;
}
}
else
{
col[row.GetRecordFromVersion(version)] = col.DataExpression.Evaluate(row, version);
}
}
}
internal void SilentlySetValue(DataRow dr, DataColumn dc, DataRowVersion version, object newValue)
{
int recordFromVersion = dr.GetRecordFromVersion(version);
bool flag = false;
if (DataStorage.IsTypeCustomType(dc.DataType) && (newValue != dc[recordFromVersion]))
{
flag = false;
}
else
{
flag = dc.CompareValueTo(recordFromVersion, newValue, true);
}
if (!flag)
{
int[] oldIndex = dr.Table.RemoveRecordFromIndexes(dr, version);
dc.SetValue(recordFromVersion, newValue);
int[] newIndex = dr.Table.InsertRecordToIndexes(dr, version);
if (dr.HasVersion(version))
{
if (version != DataRowVersion.Original)
{
dr.Table.RecordChanged(oldIndex, newIndex);
}
if (dc.dependentColumns != null)
{
dc.Table.EvaluateDependentExpressions(dc.dependentColumns, dr, version, null);
}
}
}
dr.ResetLastChangedColumn();
}
internal int[] RemoveRecordFromIndexes(DataRow row, DataRowVersion version)
{
int count = this.LiveIndexes.Count;
int[] numArray = new int[count];
int recordFromVersion = row.GetRecordFromVersion(version);
DataViewRowState recordState = row.GetRecordState(recordFromVersion);
while (--count >= 0)
{
if (row.HasVersion(version) && ((recordState & this.indexes[count].RecordStates) != DataViewRowState.None))
{
int index = this.indexes[count].GetIndex(recordFromVersion);
if (index > -1)
{
numArray[count] = index;
this.indexes[count].DeleteRecordFromIndex(index);
}
else
{
numArray[count] = -1;
}
}
else
{
numArray[count] = -1;
}
}
return numArray;
}
internal int[] InsertRecordToIndexes(DataRow row, DataRowVersion version)
{
int count = this.LiveIndexes.Count;
int[] numArray = new int[count];
int recordFromVersion = row.GetRecordFromVersion(version);
DataViewRowState recordState = row.GetRecordState(recordFromVersion);
while (--count >= 0)
{
if (row.HasVersion(version))
{
if ((recordState & this.indexes[count].RecordStates) != DataViewRowState.None)
{
numArray[count] = this.indexes[count].InsertRecordToIndex(recordFromVersion);
}
else
{
numArray[count] = -1;
}
}
}
return numArray;
}
