[Test] public void Equals_O() { DataSet ds = new DataSet(); DataTable dtParent = DataProvider.CreateParentDataTable(); ds.Tables.Add(dtParent); UniqueConstraint uc1,uc2; uc1 = new UniqueConstraint(dtParent.Columns[0]); uc2 = new UniqueConstraint(dtParent.Columns[1]); // different columnn Assert.AreEqual(false, uc1.Equals(uc2), "UC3"); //Two System.Data.ForeignKeyConstraint are equal if they constrain the same columns. // same column uc2 = new UniqueConstraint(dtParent.Columns[0]); Assert.AreEqual(true, uc1.Equals(uc2), "UC4"); }
private object[] SetupSchemaWithKeyInfo(MissingMappingAction mappingAction, MissingSchemaAction schemaAction, bool gettingData, DataColumn parentChapterColumn, object chapterValue) { DbSchemaRow[] sortedSchemaRows = DbSchemaRow.GetSortedSchemaRows(this._schemaTable, this._dataReader.ReturnProviderSpecificTypes); if (sortedSchemaRows.Length == 0) { this._dataTable = null; return null; } bool flag = (this._dataTable.PrimaryKey.Length == 0 && this._dataTable.Rows.Count == 0) || 0 == this._dataTable.Columns.Count; DataColumn[] array = null; int num = 0; bool flag2 = true; string text = null; string text2 = null; bool flag3 = false; bool flag4 = false; int[] array2 = null; bool[] array3 = null; int num2 = 0; object[] result = null; List<object> items = null; DataColumnCollection columns = this._dataTable.Columns; try { for (int i = 0; i < sortedSchemaRows.Length; i++) { DbSchemaRow dbSchemaRow = sortedSchemaRows[i]; int unsortedIndex = dbSchemaRow.UnsortedIndex; bool flag5 = false; Type type = dbSchemaRow.DataType; if (null == type) { type = this._dataReader.GetFieldType(i); } if (null == type) { throw new Exception("MissingDataReaderFieldType"); } if (typeof(IDataReader).IsAssignableFrom(type)) { if (array3 == null) { array3 = new bool[sortedSchemaRows.Length]; } flag5 = (array3[unsortedIndex] = true); type = typeof(int); } else { if (typeof(SqlXml).IsAssignableFrom(type)) { if (this._xmlMap == null) { this._xmlMap = new int[sortedSchemaRows.Length]; } this._xmlMap[i] = 1; } else { if (typeof(XmlReader).IsAssignableFrom(type)) { type = typeof(string); if (this._xmlMap == null) { this._xmlMap = new int[sortedSchemaRows.Length]; } this._xmlMap[i] = 2; } } } DataColumn dataColumn = null; if (!dbSchemaRow.IsHidden) { dataColumn = this._tableMapping.GetDataColumn(this._fieldNames[i], type, this._dataTable, mappingAction, schemaAction); } string baseTableName = dbSchemaRow.BaseTableName; if (dataColumn == null) { if (array2 == null) { array2 = this.CreateIndexMap(sortedSchemaRows.Length, unsortedIndex); } array2[unsortedIndex] = -1; if (dbSchemaRow.IsKey && (flag3 || dbSchemaRow.BaseTableName == text)) { flag = false; array = null; } } else { if (this._xmlMap != null && this._xmlMap[i] != 0) { if (typeof(SqlXml) == dataColumn.DataType) { this._xmlMap[i] = 1; } else { if (typeof(XmlDocument) == dataColumn.DataType) { this._xmlMap[i] = 2; } else { this._xmlMap[i] = 0; int num3 = 0; for (int j = 0; j < this._xmlMap.Length; j++) { num3 += this._xmlMap[j]; } if (num3 == 0) { this._xmlMap = null; } } } } if (dbSchemaRow.IsKey && baseTableName != text) { if (text == null) { text = baseTableName; } else { flag3 = true; } } if (flag5) { if (dataColumn.Table == null) { dataColumn.AllowDBNull = false; dataColumn.AutoIncrement = true; dataColumn.ReadOnly = true; } else { if (!dataColumn.AutoIncrement) { throw new Exception("FillChapterAutoIncrement"); } } } else { if (!flag4 && baseTableName != text2 && !string.IsNullOrEmpty(baseTableName)) { if (text2 == null) { text2 = baseTableName; } else { flag4 = true; } } if (dbSchemaRow.IsAutoIncrement && IsAutoIncrementType(type)) { dataColumn.AutoIncrement = true; if (!dbSchemaRow.AllowDBNull) { dataColumn.AllowDBNull = false; } } if (type == typeof(string)) { dataColumn.MaxLength = ((dbSchemaRow.Size > 0) ? dbSchemaRow.Size : -1); } if (dbSchemaRow.IsReadOnly) { dataColumn.ReadOnly = true; } if (!dbSchemaRow.AllowDBNull && (!dbSchemaRow.IsReadOnly || dbSchemaRow.IsKey)) { dataColumn.AllowDBNull = false; } if (dbSchemaRow.IsUnique && !dbSchemaRow.IsKey && !type.IsArray) { dataColumn.Unique = true; if (!dbSchemaRow.AllowDBNull) { dataColumn.AllowDBNull = false; } } } if (dataColumn.Table == null) { this.AddAdditionalProperties(dataColumn, dbSchemaRow.DataRow); this.AddItemToAllowRollback(ref items, dataColumn); columns.Add(dataColumn); } if (flag && dbSchemaRow.IsKey) { if (array == null) { array = new DataColumn[sortedSchemaRows.Length]; } array[num++] = dataColumn; if (flag2 && dataColumn.AllowDBNull) { flag2 = false; } } if (array2 != null) { array2[unsortedIndex] = dataColumn.Ordinal; } else { if (unsortedIndex != dataColumn.Ordinal) { array2 = this.CreateIndexMap(sortedSchemaRows.Length, unsortedIndex); array2[unsortedIndex] = dataColumn.Ordinal; } } num2++; } } bool flag6 = false; DataColumn dataColumn2 = null; if (chapterValue != null) { Type type2 = chapterValue.GetType(); dataColumn2 = this._tableMapping.GetDataColumn(this._tableMapping.SourceTable, type2, this._dataTable, mappingAction, schemaAction); if (dataColumn2 != null) { if (dataColumn2.Table == null) { dataColumn2.ReadOnly = true; dataColumn2.AllowDBNull = false; this.AddItemToAllowRollback(ref items, dataColumn2); columns.Add(dataColumn2); flag6 = (null != parentChapterColumn); } num2++; } } if (0 < num2) { if (this._dataSet != null && this._dataTable.DataSet == null) { this.AddItemToAllowRollback(ref items, this._dataTable); this._dataSet.Tables.Add(this._dataTable); } if (flag && array != null) { if (num < array.Length) { array = this.ResizeColumnArray(array, num); } if (flag2) { this._dataTable.PrimaryKey = array; } else { UniqueConstraint uniqueConstraint = new UniqueConstraint("", array); ConstraintCollection constraints = this._dataTable.Constraints; int count = constraints.Count; for (int k = 0; k < count; k++) { if (uniqueConstraint.Equals(constraints[k])) { uniqueConstraint = null; break; } } if (uniqueConstraint != null) { constraints.Add(uniqueConstraint); } } } if (!flag4 && !string.IsNullOrEmpty(text2) && string.IsNullOrEmpty(this._dataTable.TableName)) { this._dataTable.TableName = text2; } if (gettingData) { this._indexMap = array2; this._chapterMap = array3; result = this.SetupMapping(sortedSchemaRows.Length, columns, dataColumn2, chapterValue); } else { this._mappedMode = -1; } } else { this._dataTable = null; } if (flag6) { this.AddRelation(parentChapterColumn, dataColumn2); } } catch (Exception e) { this.RollbackAddedItems(items); throw e; } return result; }
private object[] SetupSchemaWithKeyInfo(MissingMappingAction mappingAction, MissingSchemaAction schemaAction, bool gettingData, DataColumn parentChapterColumn, object chapterValue) { // must sort rows from schema table by ordinal because Jet is sorted by coumn name DbSchemaRow[] schemaRows = DbSchemaRow.GetSortedSchemaRows(_schemaTable, _dataReader.ReturnProviderSpecificTypes); // MDAC 60609 Debug.Assert(null != schemaRows, "SchemaSetup - null DbSchemaRow[]"); Debug.Assert(_dataReader.FieldCount <= schemaRows.Length, "unexpected fewer rows in Schema than FieldCount"); if (0 == schemaRows.Length) { _dataTable = null; return (object[])null; } // Everett behavior, always add a primary key if a primary key didn't exist before // Whidbey behavior, same as Everett unless using LoadOption then add primary key only if no columns previously existed bool addPrimaryKeys = (((0 == _dataTable.PrimaryKey.Length) && ((4 <= (int)_loadOption) || (0 == _dataTable.Rows.Count))) || (0 == _dataTable.Columns.Count)); // MDAC 67033 DataColumn[] keys = null; int keyCount = 0; bool isPrimary = true; // assume key info (if any) is about a primary key string keyBaseTable = null; string commonBaseTable = null; bool keyFromMultiTable = false; bool commonFromMultiTable = false; int[] columnIndexMap = null; bool[] chapterIndexMap = null; int mappingCount = 0; object[] dataValues = null; List<object> addedItems = null; DataColumnCollection columnCollection = _dataTable.Columns; try { for(int sortedIndex = 0; sortedIndex < schemaRows.Length; ++sortedIndex) { DbSchemaRow schemaRow = schemaRows[sortedIndex]; int unsortedIndex = schemaRow.UnsortedIndex; // MDAC 67050 bool ischapter = false; Type fieldType = schemaRow.DataType; if (null == fieldType) { fieldType = _dataReader.GetFieldType(sortedIndex); } if (null == fieldType) { throw ADP.MissingDataReaderFieldType(sortedIndex); } // if IDataReader, hierarchy exists and we will use an Int32,AutoIncrementColumn in this table if (typeof(IDataReader).IsAssignableFrom(fieldType)) { if (null == chapterIndexMap) { chapterIndexMap = new bool[schemaRows.Length]; } chapterIndexMap[unsortedIndex] = ischapter = true; fieldType = typeof(Int32); } else if (typeof(System.Data.SqlTypes.SqlXml).IsAssignableFrom(fieldType)) { if (null == _xmlMap) { _xmlMap = new int[schemaRows.Length]; } _xmlMap[sortedIndex] = SqlXml; } else if (typeof(System.Xml.XmlReader).IsAssignableFrom(fieldType)) { fieldType = typeof(String); if (null == _xmlMap) { _xmlMap = new int[schemaRows.Length]; } _xmlMap[sortedIndex] = XmlDocument; } DataColumn dataColumn = null; if (!schemaRow.IsHidden ) { dataColumn = _tableMapping.GetDataColumn(_fieldNames[sortedIndex], fieldType, _dataTable, mappingAction, schemaAction); } string basetable = /*schemaRow.BaseServerName+schemaRow.BaseCatalogName+schemaRow.BaseSchemaName+*/ schemaRow.BaseTableName; if (null == dataColumn) { if (null == columnIndexMap) { columnIndexMap = CreateIndexMap(schemaRows.Length, unsortedIndex); } columnIndexMap[unsortedIndex] = -1; // if the column is not mapped and it is a key, then don't add any key information if (schemaRow.IsKey) { // MDAC 90822 #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: partial primary key detected"); } #endif // if the hidden key comes from a different table - don't throw away the primary key // example SELECT [T2].[ID], [T2].[ProdID], [T2].[VendorName] FROM [Vendor] AS [T2], [Prod] AS [T1] WHERE (([T1].[ProdID] = [T2].[ProdID])) if (keyFromMultiTable || (schemaRow.BaseTableName == keyBaseTable)) { // WebData 100376 addPrimaryKeys = false; // don't add any future keys now keys = null; // get rid of any keys we've seen } } continue; // null means ignore (mapped to nothing) } else if ((null != _xmlMap) && (0 != _xmlMap[sortedIndex])) { if (typeof(System.Data.SqlTypes.SqlXml) == dataColumn.DataType) { _xmlMap[sortedIndex] = SqlXml; } else if (typeof(System.Xml.XmlDocument) == dataColumn.DataType) { _xmlMap[sortedIndex] = XmlDocument; } else { _xmlMap[sortedIndex] = 0; // datacolumn is not a specific Xml dataType, i.e. string int total = 0; for(int x = 0; x < _xmlMap.Length; ++x) { total += _xmlMap[x]; } if (0 == total) { // not mapping to a specific Xml datatype, get rid of the map _xmlMap = null; } } } if (schemaRow.IsKey) { if (basetable != keyBaseTable) { if (null == keyBaseTable) { keyBaseTable = basetable; } else keyFromMultiTable = true; } } if (ischapter) { if (null == dataColumn.Table) { dataColumn.AllowDBNull = false; dataColumn.AutoIncrement = true; dataColumn.ReadOnly = true; } else if (!dataColumn.AutoIncrement) { throw ADP.FillChapterAutoIncrement(); } } else {// MDAC 67033 if (!commonFromMultiTable) { if ((basetable != commonBaseTable) && (!ADP.IsEmpty(basetable))) { if (null == commonBaseTable) { commonBaseTable = basetable; } else { commonFromMultiTable = true; } } } if (4 <= (int)_loadOption) { if (schemaRow.IsAutoIncrement && DataColumn.IsAutoIncrementType(fieldType)) { // dataColumn.AutoIncrement = true; if (!schemaRow.AllowDBNull) { // MDAC 71060 dataColumn.AllowDBNull = false; } } // setup maxLength, only for string columns since this is all the DataSet supports if (fieldType == typeof(string)) { //@devnote: schemaRow.Size is count of characters for string columns, count of bytes otherwise dataColumn.MaxLength = schemaRow.Size>0?schemaRow.Size:-1; } if (schemaRow.IsReadOnly) { dataColumn.ReadOnly = true; } if (!schemaRow.AllowDBNull && (!schemaRow.IsReadOnly || schemaRow.IsKey)) { // MDAC 71060, 72252 dataColumn.AllowDBNull = false; } if (schemaRow.IsUnique && !schemaRow.IsKey && !fieldType.IsArray) { // note, arrays are not comparable so only mark non-arrays as unique, ie timestamp columns // are unique, but not comparable dataColumn.Unique = true; if (!schemaRow.AllowDBNull) { // MDAC 71060 dataColumn.AllowDBNull = false; } } } else if (null == dataColumn.Table) { dataColumn.AutoIncrement = schemaRow.IsAutoIncrement; dataColumn.AllowDBNull = schemaRow.AllowDBNull; dataColumn.ReadOnly = schemaRow.IsReadOnly; dataColumn.Unique = schemaRow.IsUnique; if (fieldType == typeof(string) || (fieldType == typeof(SqlTypes.SqlString))) { //@devnote: schemaRow.Size is count of characters for string columns, count of bytes otherwise dataColumn.MaxLength = schemaRow.Size; } } } if (null == dataColumn.Table) { if (4 > (int)_loadOption) { AddAdditionalProperties(dataColumn, schemaRow.DataRow); } AddItemToAllowRollback(ref addedItems, dataColumn); columnCollection.Add(dataColumn); } // The server sends us one key per table according to these rules. // // 1. If the table has a primary key, the server sends us this key. // 2. If the table has a primary key and a unique key, it sends us the primary key // 3. if the table has no primary key but has a unique key, it sends us the unique key // // In case 3, we will promote a unique key to a primary key IFF all the columns that compose // that key are not nullable since no columns in a primary key can be null. If one or more // of the keys is nullable, then we will add a unique constraint. // if (addPrimaryKeys && schemaRow.IsKey) { // MDAC 67033 if (keys == null) { keys = new DataColumn[schemaRows.Length]; } keys[keyCount++] = dataColumn; #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: building list of " + ((isPrimary) ? "PrimaryKey" : "UniqueConstraint")); } #endif // see case 3 above, we do want dataColumn.AllowDBNull not schemaRow.AllowDBNull // otherwise adding PrimaryKey will change AllowDBNull to false if (isPrimary && dataColumn.AllowDBNull) { // MDAC 72241 #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: changing PrimaryKey into UniqueContraint"); } #endif isPrimary = false; } } if (null != columnIndexMap) { columnIndexMap[unsortedIndex] = dataColumn.Ordinal; } else if (unsortedIndex != dataColumn.Ordinal) { columnIndexMap = CreateIndexMap(schemaRows.Length, unsortedIndex); columnIndexMap[unsortedIndex] = dataColumn.Ordinal; } mappingCount++; } bool addDataRelation = false; DataColumn chapterColumn = null; if (null != chapterValue) { // add the extra column in the child table Type fieldType = chapterValue.GetType(); chapterColumn = _tableMapping.GetDataColumn(_tableMapping.SourceTable, fieldType, _dataTable, mappingAction, schemaAction); if (null != chapterColumn) { if (null == chapterColumn.Table) { chapterColumn.ReadOnly = true; // MDAC 71878 chapterColumn.AllowDBNull = false; AddItemToAllowRollback(ref addedItems, chapterColumn); columnCollection.Add(chapterColumn); addDataRelation = (null != parentChapterColumn); } mappingCount++; } } if (0 < mappingCount) { if ((null != _dataSet) && null == _dataTable.DataSet) { AddItemToAllowRollback(ref addedItems, _dataTable); _dataSet.Tables.Add(_dataTable); } // setup the key if (addPrimaryKeys && (null != keys)) { // MDAC 67033 if (keyCount < keys.Length) { keys = ResizeColumnArray(keys, keyCount); } // MDAC 66188 if (isPrimary) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: set_PrimaryKey"); } #endif _dataTable.PrimaryKey = keys; } else { UniqueConstraint unique = new UniqueConstraint("", keys); ConstraintCollection constraints = _dataTable.Constraints; int constraintCount = constraints.Count; for (int i = 0; i < constraintCount; ++i) { if (unique.Equals(constraints[i])) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: duplicate Contraint detected"); } #endif unique = null; break; } } if (null != unique) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: adding new UniqueConstraint"); } #endif constraints.Add(unique); } } } if (!commonFromMultiTable && !ADP.IsEmpty(commonBaseTable) && ADP.IsEmpty(_dataTable.TableName)) { _dataTable.TableName = commonBaseTable; } if (gettingData) { _indexMap = columnIndexMap; _chapterMap = chapterIndexMap; dataValues = SetupMapping(schemaRows.Length, columnCollection, chapterColumn, chapterValue); } else { // debug only, but for retail debug ability _mappedMode = -1; } } else { _dataTable = null; } if (addDataRelation) { AddRelation(parentChapterColumn, chapterColumn); } } catch (Exception e) { if (ADP.IsCatchableOrSecurityExceptionType(e)) { RollbackAddedItems(addedItems); } throw; } return dataValues; }
//Activate This Construntor to log All To Standard output //public TestClass():base(true){} //Activate this constructor to log Failures to a log file //public TestClass(System.IO.TextWriter tw):base(tw, false){} //Activate this constructor to log All to a log file //public TestClass(System.IO.TextWriter tw):base(tw, true){} //BY DEFAULT LOGGING IS DONE TO THE STANDARD OUTPUT ONLY FOR FAILURES public void run() { Exception exp = null; DataSet ds = new DataSet(); DataTable dtParent = GHTUtils.DataProvider.CreateParentDataTable(); ds.Tables.Add(dtParent); UniqueConstraint uc1,uc2; uc1 = new UniqueConstraint(dtParent.Columns[0]); uc2 = new UniqueConstraint(dtParent.Columns[1]); try { BeginCase("different columnn"); Compare(uc1.Equals(uc2),false); } catch(Exception ex) {exp = ex;} finally {EndCase(exp); exp = null;} //Two System.Data.ForeignKeyConstraint are equal if they constrain the same columns. try { BeginCase("same column"); uc2 = new UniqueConstraint(dtParent.Columns[0]); Compare(uc1.Equals(uc2),true); } catch(Exception ex) {exp = ex;} finally {EndCase(exp); exp = null;} }
public void EqualsAndHashCode () { UniqueConstraint cst = new UniqueConstraint (new DataColumn [] { _table.Columns[0], _table.Columns[1]}); UniqueConstraint cst2 = new UniqueConstraint (new DataColumn [] { _table.Columns[1], _table.Columns[0]}); UniqueConstraint cst3 = new UniqueConstraint (_table.Columns [0]); UniqueConstraint cst4 = new UniqueConstraint (_table.Columns [2]); //true Assert.That (cst.Equals (cst2), Is.True, "A0"); //false Assert.That (cst.Equals (23), Is.False, "A1"); Assert.That (cst.Equals (cst3), Is.False, "A2"); Assert.That (cst3.Equals (cst), Is.False, "A3"); Assert.That (cst.Equals (cst4), Is.False, "A4"); //true Assert.That (cst.GetHashCode (), Is.EqualTo (cst2.GetHashCode ()), "HashEquals"); //false Assert.That (cst.GetHashCode (), Is.Not.EqualTo (cst3.GetHashCode ()), "Hash Not Equals"); }
private object[] SetupSchemaWithKeyInfo(MissingMappingAction mappingAction, MissingSchemaAction schemaAction, bool gettingData, DataColumn parentChapterColumn, object chapterValue) { DbSchemaRow[] sortedSchemaRows = DbSchemaRow.GetSortedSchemaRows(this._schemaTable, this._dataReader.ReturnProviderSpecificTypes); if (sortedSchemaRows.Length == 0) { this._dataTable = null; return null; } bool flag3 = ((this._dataTable.PrimaryKey.Length == 0) && ((((LoadOption) 4) <= this._loadOption) || (this._dataTable.Rows.Count == 0))) || (0 == this._dataTable.Columns.Count); DataColumn[] rgcol = null; int len = 0; bool flag2 = true; string str3 = null; string str2 = null; bool flag6 = false; bool flag = false; int[] numArray = null; bool[] flagArray = null; int num3 = 0; object[] objArray = null; List<object> items = null; DataColumnCollection columnCollection = this._dataTable.Columns; try { for (int i = 0; i < sortedSchemaRows.Length; i++) { DbSchemaRow row = sortedSchemaRows[i]; int unsortedIndex = row.UnsortedIndex; bool flag5 = false; Type dataType = row.DataType; if (null == dataType) { dataType = this._dataReader.GetFieldType(i); } if (null == dataType) { throw ADP.MissingDataReaderFieldType(i); } if (typeof(IDataReader).IsAssignableFrom(dataType)) { if (flagArray == null) { flagArray = new bool[sortedSchemaRows.Length]; } flagArray[unsortedIndex] = flag5 = true; dataType = typeof(int); } else if (typeof(System.Data.SqlTypes.SqlXml).IsAssignableFrom(dataType)) { if (this._xmlMap == null) { this._xmlMap = new int[sortedSchemaRows.Length]; } this._xmlMap[i] = 1; } else if (typeof(XmlReader).IsAssignableFrom(dataType)) { dataType = typeof(string); if (this._xmlMap == null) { this._xmlMap = new int[sortedSchemaRows.Length]; } this._xmlMap[i] = 2; } DataColumn targetColumn = null; if (!row.IsHidden) { targetColumn = this._tableMapping.GetDataColumn(this._fieldNames[i], dataType, this._dataTable, mappingAction, schemaAction); } string baseTableName = row.BaseTableName; if (targetColumn == null) { if (numArray == null) { numArray = this.CreateIndexMap(sortedSchemaRows.Length, unsortedIndex); } numArray[unsortedIndex] = -1; if (row.IsKey && (flag6 || (row.BaseTableName == str3))) { flag3 = false; rgcol = null; } } else { if ((this._xmlMap != null) && (this._xmlMap[i] != 0)) { if (typeof(System.Data.SqlTypes.SqlXml) == targetColumn.DataType) { this._xmlMap[i] = 1; } else if (typeof(System.Xml.XmlDocument) == targetColumn.DataType) { this._xmlMap[i] = 2; } else { this._xmlMap[i] = 0; int num7 = 0; for (int j = 0; j < this._xmlMap.Length; j++) { num7 += this._xmlMap[j]; } if (num7 == 0) { this._xmlMap = null; } } } if (row.IsKey && (baseTableName != str3)) { if (str3 == null) { str3 = baseTableName; } else { flag6 = true; } } if (flag5) { if (targetColumn.Table != null) { if (!targetColumn.AutoIncrement) { throw ADP.FillChapterAutoIncrement(); } } else { targetColumn.AllowDBNull = false; targetColumn.AutoIncrement = true; targetColumn.ReadOnly = true; } } else { if ((!flag && (baseTableName != str2)) && !ADP.IsEmpty(baseTableName)) { if (str2 == null) { str2 = baseTableName; } else { flag = true; } } if (((LoadOption) 4) <= this._loadOption) { if (row.IsAutoIncrement && DataColumn.IsAutoIncrementType(dataType)) { targetColumn.AutoIncrement = true; if (!row.AllowDBNull) { targetColumn.AllowDBNull = false; } } if (dataType == typeof(string)) { targetColumn.MaxLength = (row.Size > 0) ? row.Size : -1; } if (row.IsReadOnly) { targetColumn.ReadOnly = true; } if (!row.AllowDBNull && (!row.IsReadOnly || row.IsKey)) { targetColumn.AllowDBNull = false; } if ((row.IsUnique && !row.IsKey) && !dataType.IsArray) { targetColumn.Unique = true; if (!row.AllowDBNull) { targetColumn.AllowDBNull = false; } } } else if (targetColumn.Table == null) { targetColumn.AutoIncrement = row.IsAutoIncrement; targetColumn.AllowDBNull = row.AllowDBNull; targetColumn.ReadOnly = row.IsReadOnly; targetColumn.Unique = row.IsUnique; if ((dataType == typeof(string)) || (dataType == typeof(SqlString))) { targetColumn.MaxLength = row.Size; } } } if (targetColumn.Table == null) { if (((LoadOption) 4) > this._loadOption) { this.AddAdditionalProperties(targetColumn, row.DataRow); } this.AddItemToAllowRollback(ref items, targetColumn); columnCollection.Add(targetColumn); } if (flag3 && row.IsKey) { if (rgcol == null) { rgcol = new DataColumn[sortedSchemaRows.Length]; } rgcol[len++] = targetColumn; if (flag2 && targetColumn.AllowDBNull) { flag2 = false; } } if (numArray != null) { numArray[unsortedIndex] = targetColumn.Ordinal; } else if (unsortedIndex != targetColumn.Ordinal) { numArray = this.CreateIndexMap(sortedSchemaRows.Length, unsortedIndex); numArray[unsortedIndex] = targetColumn.Ordinal; } num3++; } } bool flag4 = false; DataColumn column2 = null; if (chapterValue != null) { Type type = chapterValue.GetType(); column2 = this._tableMapping.GetDataColumn(this._tableMapping.SourceTable, type, this._dataTable, mappingAction, schemaAction); if (column2 != null) { if (column2.Table == null) { column2.ReadOnly = true; column2.AllowDBNull = false; this.AddItemToAllowRollback(ref items, column2); columnCollection.Add(column2); flag4 = null != parentChapterColumn; } num3++; } } if (0 < num3) { if ((this._dataSet != null) && (this._dataTable.DataSet == null)) { this.AddItemToAllowRollback(ref items, this._dataTable); this._dataSet.Tables.Add(this._dataTable); } if (flag3 && (rgcol != null)) { if (len < rgcol.Length) { rgcol = this.ResizeColumnArray(rgcol, len); } if (flag2) { this._dataTable.PrimaryKey = rgcol; } else { UniqueConstraint constraint = new UniqueConstraint("", rgcol); ConstraintCollection constraints = this._dataTable.Constraints; int count = constraints.Count; for (int k = 0; k < count; k++) { if (constraint.Equals(constraints[k])) { constraint = null; break; } } if (constraint != null) { constraints.Add(constraint); } } } if ((!flag && !ADP.IsEmpty(str2)) && ADP.IsEmpty(this._dataTable.TableName)) { this._dataTable.TableName = str2; } if (gettingData) { this._indexMap = numArray; this._chapterMap = flagArray; objArray = this.SetupMapping(sortedSchemaRows.Length, columnCollection, column2, chapterValue); } else { this._mappedMode = -1; } } else { this._dataTable = null; } if (flag4) { this.AddRelation(parentChapterColumn, column2); } } catch (Exception exception) { if (ADP.IsCatchableOrSecurityExceptionType(exception)) { this.RollbackAddedItems(items); } throw; } return objArray; }
public void EqualsAndHashCode() { UniqueConstraint cst = new UniqueConstraint( new DataColumn [] { _table.Columns[0], _table.Columns[1]}); UniqueConstraint cst2 = new UniqueConstraint( new DataColumn [] { _table.Columns[1], _table.Columns[0]}); UniqueConstraint cst3 = new UniqueConstraint(_table.Columns[0]); UniqueConstraint cst4 = new UniqueConstraint(_table.Columns[2]); //true Assert(cst.Equals(cst2) == true); //false Assert("A1", cst.Equals(23) == false); Assert("A2", cst.Equals(cst3) == false); Assert("A3", cst3.Equals(cst) == false); Assert("A4", cst.Equals(cst4) == false); //true Assert("HashEquals", cst.GetHashCode() == cst2.GetHashCode()); //false Assert("Hash Not Equals", (cst.GetHashCode() == cst3.GetHashCode()) == false); }