private CompareValueTo ( int record1, object value, bool checkType ) : bool | ||
record1 | int | |
value | object | |
checkType | bool | |
return | bool |
private int FindNodeByKey(object?originalKey) { int x, c; if (_indexFields.Length != 1) { throw ExceptionBuilder.IndexKeyLength(_indexFields.Length, 1); } x = _records.root; if (IndexTree.NIL != x) { // otherwise storage may not exist DataColumn column = _indexFields[0].Column; object? key = column.ConvertValue(originalKey); x = _records.root; if (_indexFields[0].IsDescending) { while (IndexTree.NIL != x) { c = column.CompareValueTo(_records.Key(x), key); if (c == 0) { break; } if (c < 0) { x = _records.Left(x); } // < for decsending else { x = _records.Right(x); } } } else { while (IndexTree.NIL != x) { c = column.CompareValueTo(_records.Key(x), key); if (c == 0) { break; } if (c > 0) { x = _records.Left(x); } // > for ascending else { x = _records.Right(x); } } } } return(x); }
private int FindNodeByKey(object originalKey) { if (this.IndexFields.Length != 1) { throw ExceptionBuilder.IndexKeyLength(this.IndexFields.Length, 1); } int root = this.records.root; if (root != 0) { int num2; DataColumn column = this.IndexFields[0].Column; object obj2 = column.ConvertValue(originalKey); root = this.records.root; if (!this.IndexFields[0].IsDescending) { while (root != 0) { num2 = column.CompareValueTo(this.records.Key(root), obj2); if (num2 == 0) { return root; } if (num2 > 0) { root = this.records.Left(root); } else { root = this.records.Right(root); } } return root; } while (root != 0) { num2 = column.CompareValueTo(this.records.Key(root), obj2); if (num2 == 0) { return root; } if (num2 < 0) { root = this.records.Left(root); } else { root = this.records.Right(root); } } } return root; }
internal override void CheckConstraint(DataRow childRow, DataRowAction action) { if ((action == DataRowAction.Change || action == DataRowAction.Add || action == DataRowAction.Rollback) && Table.DataSet != null && Table.DataSet.EnforceConstraints && childRow.HasKeyChanged(_childKey)) { // This branch is for cascading case verification. DataRowVersion version = (action == DataRowAction.Rollback) ? DataRowVersion.Original : DataRowVersion.Current; object[] childKeyValues = childRow.GetKeyValues(_childKey); // check to see if this is just a change to my parent's proposed value. if (childRow.HasVersion(version)) { // this is the new proposed value for the parent. DataRow parentRow = DataRelation.GetParentRow(ParentKey, ChildKey, childRow, version); if (parentRow != null && parentRow._inCascade) { object[] parentKeyValues = parentRow.GetKeyValues(_parentKey, action == DataRowAction.Rollback ? version : DataRowVersion.Default); int parentKeyValuesRecord = childRow.Table.NewRecord(); childRow.Table.SetKeyValues(_childKey, parentKeyValues, parentKeyValuesRecord); if (_childKey.RecordsEqual(childRow._tempRecord, parentKeyValuesRecord)) { return; } } } // now check to see if someone exists... it will have to be in a parent row's current, not a proposed. object[] childValues = childRow.GetKeyValues(_childKey); if (!IsKeyNull(childValues)) { Index parentIndex = _parentKey.GetSortIndex(); if (!parentIndex.IsKeyInIndex(childValues)) { // could be self-join constraint if (_childKey.Table == _parentKey.Table && childRow._tempRecord != -1) { int lo = 0; for (lo = 0; lo < childValues.Length; lo++) { DataColumn column = _parentKey.ColumnsReference[lo]; object value = column.ConvertValue(childValues[lo]); if (0 != column.CompareValueTo(childRow._tempRecord, value)) { break; } } if (lo == childValues.Length) { return; } } throw ExceptionBuilder.ForeignKeyViolation(ConstraintName, childKeyValues); } } } }
internal override void CheckConstraint(DataRow childRow, DataRowAction action) { if (((((action == DataRowAction.Change) || (action == DataRowAction.Add)) || (action == DataRowAction.Rollback)) && ((this.Table.DataSet != null) && this.Table.DataSet.EnforceConstraints)) && childRow.HasKeyChanged(this.childKey)) { DataRowVersion version = (action == DataRowAction.Rollback) ? DataRowVersion.Original : DataRowVersion.Current; object[] keyValues = childRow.GetKeyValues(this.childKey); if (childRow.HasVersion(version)) { DataRow row = DataRelation.GetParentRow(this.ParentKey, this.ChildKey, childRow, version); if ((row != null) && row.inCascade) { object[] objArray2 = row.GetKeyValues(this.parentKey, (action == DataRowAction.Rollback) ? version : DataRowVersion.Default); int record = childRow.Table.NewRecord(); childRow.Table.SetKeyValues(this.childKey, objArray2, record); if (this.childKey.RecordsEqual(childRow.tempRecord, record)) { return; } } } object[] values = childRow.GetKeyValues(this.childKey); if (!this.IsKeyNull(values) && !this.parentKey.GetSortIndex().IsKeyInIndex(values)) { if ((this.childKey.Table == this.parentKey.Table) && (childRow.tempRecord != -1)) { int index = 0; index = 0; while (index < values.Length) { DataColumn column = this.parentKey.ColumnsReference[index]; object obj2 = column.ConvertValue(values[index]); if (column.CompareValueTo(childRow.tempRecord, obj2) != 0) { break; } index++; } if (index == values.Length) { return; } } throw ExceptionBuilder.ForeignKeyViolation(this.ConstraintName, keyValues); } } }
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(); }
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(); }