public void Add() { ConstraintCollection col = _table.Constraints; col.Add(_constraint1); col.Add(_constraint2); Assert.That(col.Count, Is.EqualTo(2), "Count doesn't equal added."); }
public void Add() { ConstraintCollection col = _table.Constraints; col.Add(_constraint1); col.Add(_constraint2); AssertEquals("Count doesn't equal added.", 2, col.Count); }
public void Add() { ConstraintCollection col = _table.Constraints; col.Add(_constraint1); col.Add(_constraint2); Assert.Equal(2, col.Count); }
public void AddExceptions() { ConstraintCollection col = _table.Constraints; Assert.Throws <ArgumentNullException>(() => col.Add(null)); _constraint1.ConstraintName = "Dog"; col.Add(_constraint1); Assert.Throws <DataException>(() => col.Add(_constraint1)); }
public void AddExceptions() { ConstraintCollection col = _table.Constraints; //null try { col.Add(null); Assert.Fail("B1: Failed to throw ArgumentNullException."); } catch (ArgumentNullException) { } catch (AssertionException exc) { throw exc; } catch { Assert.Fail("A1: Wrong exception type"); } //duplicate name try { _constraint1.ConstraintName = "Dog"; _constraint2.ConstraintName = "dog"; //case insensitive col.Add(_constraint1); col.Add(_constraint2); col.Remove(_constraint2); // only for !1.0 col.Remove(_constraint1); } catch (AssertionException exc) { throw exc; } /* Don't use such catch. They cover our eyes from the exact exception location. * catch (Exception exc) * { * Assert.Fail("A2: Wrong exception type. " + exc.ToString()); * } */ //Constraint Already exists try { col.Add(_constraint1); col.Remove(_constraint1); } catch (ArgumentException) { } catch (AssertionException exc) { throw exc; } catch { Assert.Fail("A3: Wrong exception type"); } }
internal static VariantConfigurationSnapshot GetSnapshot(ADRawEntry executingUser, IEnumerable <KeyValuePair <string, string> > additionalConstraints) { if (executingUser == null) { return(null); } VariantConfigurationSnapshot variantConfigurationSnapshot = null; MiniRecipient miniRecipient = new MiniRecipient(); try { try { miniRecipient[MiniRecipientSchema.UserPrincipalName] = executingUser[ADUserSchema.UserPrincipalName]; miniRecipient[ADObjectSchema.OrganizationId] = executingUser[ADObjectSchema.OrganizationId]; miniRecipient[MiniRecipientSchema.ExternalDirectoryObjectId] = executingUser[ADRecipientSchema.ExternalDirectoryObjectId]; miniRecipient[MiniRecipientSchema.Languages] = executingUser[ADOrgPersonSchema.Languages]; } catch (DataValidationException ex) { AuthZLogger.SafeAppendColumn(RpsAuthZMetadata.VariantConfigurationSnapshot, "DataValidationException", ex.Message); } ConstraintCollection constraintCollection = null; if (additionalConstraints != null) { constraintCollection = ConstraintCollection.CreateEmpty(); foreach (KeyValuePair <string, string> keyValuePair in additionalConstraints) { constraintCollection.Add(keyValuePair.Key, keyValuePair.Value); } } variantConfigurationSnapshot = VariantConfiguration.GetSnapshot(miniRecipient.GetContext(null), constraintCollection, null); AuthZLogger.SafeAppendColumn(RpsAuthZMetadata.VariantConfigurationSnapshot, "Flights", string.Join(" ", variantConfigurationSnapshot.Flights)); } catch (Exception ex2) { AuthZLogger.SafeAppendGenericError("VariantConfigurationSnapshot.Exception", ex2.Message, false); } finally { AuthZLogger.SafeAppendColumn(RpsAuthZMetadata.VariantConfigurationSnapshot, "User", executingUser[ADUserSchema.UserPrincipalName].ToString()); AuthZLogger.SafeAppendColumn(RpsAuthZMetadata.VariantConfigurationSnapshot, "Org", executingUser[ADObjectSchema.OrganizationId].ToString()); } return(variantConfigurationSnapshot); }
protected internal Viewport2D(FrameworkElement host, Plotter2D plotter) { hostElement = host; host.ClipToBounds = true; host.SizeChanged += OnHostElementSizeChanged; this.plotter = plotter; plotter.Children.CollectionChanged += OnPlotterChildrenChanged; constraints = new ConstraintCollection(this); constraints.Add(new MinimalSizeConstraint()); constraints.CollectionChanged += constraints_CollectionChanged; fitToViewConstraints = new ConstraintCollection(this); fitToViewConstraints.CollectionChanged += fitToViewConstraints_CollectionChanged; readonlyContentBoundsHosts = new ReadOnlyObservableCollection<DependencyObject>(contentBoundsHosts); UpdateVisible(); UpdateTransform(); }
protected internal Viewport2D(FrameworkElement host, Plotter2D plotter) { hostElement = host; host.ClipToBounds = true; host.SizeChanged += OnHostElementSizeChanged; this.plotter = plotter; plotter.Children.CollectionChanged += OnPlotterChildrenChanged; constraints = new ConstraintCollection(this); constraints.Add(new MinimalSizeConstraint()); constraints.CollectionChanged += constraints_CollectionChanged; fitToViewConstraints = new ConstraintCollection(this); fitToViewConstraints.CollectionChanged += fitToViewConstraints_CollectionChanged; readonlyContentBoundsHosts = new ReadOnlyObservableCollection <DependencyObject>(contentBoundsHosts); UpdateVisible(); UpdateTransform(); }
private void InitClass() { this.columnComputerID = new DataColumn("ComputerID", typeof(int), null, MappingType.Element); base.Columns.Add(this.columnComputerID); this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element); base.Columns.Add(this.columnName); this.columnflags = new DataColumn("flags", typeof(int), null, MappingType.Element); base.Columns.Add(this.columnflags); this.columnFeatureFlags = new DataColumn("FeatureFlags", typeof(int), null, MappingType.Element); base.Columns.Add(this.columnFeatureFlags); ConstraintCollection constraints = base.Constraints; DataColumn[] dataColumnArray = new DataColumn[] { this.columnComputerID }; constraints.Add(new UniqueConstraint("Constraint1", dataColumnArray, true)); this.columnComputerID.AutoIncrement = true; this.columnComputerID.AutoIncrementSeed = (long)-1; this.columnComputerID.AutoIncrementStep = (long)-1; this.columnComputerID.AllowDBNull = false; this.columnComputerID.Unique = true; this.columnName.AllowDBNull = false; this.columnName.MaxLength = 50; this.columnflags.AllowDBNull = false; this.columnFeatureFlags.AllowDBNull = false; }
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); }
private void SetupSchemaWithKeyInfo(MissingMappingAction mappingAction, MissingSchemaAction schemaAction, bool gettingData, DataColumn parentChapterColumn, object chapterValue) { #if DEBUG Debug.Assert(null != schemaTable, "null schematable"); if (AdapterSwitches.DataSchema.TraceVerbose) { ADP.TraceDataTable("SetupSchema", schemaTable); } #endif DBSchemaRow[] schemaRows = DBSchemaRow.GetSortedSchemaRows(schemaTable); // MDAC 60609 Debug.Assert(null != schemaRows, "SchemaSetup - null DBSchemaRow[]"); int count = schemaRows.Length; if (0 == count) { this.dataTable = null; return; } bool addPrimaryKeys = (0 == this.dataTable.PrimaryKey.Length); // MDAC 67033 DataColumn[] keys = null; int keyCount = 0; bool isPrimary = true; // assume key info (if any) is about a primary key int[] columnIndexMap = null; bool[] chapterIndexMap = null; int mappingCount = 0; GenerateFieldNames(count); DataColumnCollection columnCollection = null; for (int sortedIndex = 0; sortedIndex < count; ++sortedIndex) { DBSchemaRow schemaRow = schemaRows[sortedIndex]; int unsortedIndex = schemaRow.UnsortedIndex; // MDAC 67050 DataColumnMapping columnMapping = null; Type fieldType = schemaRow.DataType; DataColumn dataColumn = null; if (!schemaRow.IsHidden) { columnMapping = tableMapping.GetColumnMappingBySchemaAction(fieldNames[sortedIndex], mappingAction); } bool ischapter = false; if ((null != columnMapping) && typeof(IDataReader).IsAssignableFrom(fieldType)) { if (null == chapterIndexMap) { chapterIndexMap = new bool[count]; } chapterIndexMap[unsortedIndex] = ischapter = true; fieldType = typeof(Int32); } if (columnMapping != null) { dataColumn = columnMapping.GetDataColumnBySchemaAction(this.dataTable, fieldType, schemaAction); } if (null == dataColumn) { if (null == columnIndexMap) { columnIndexMap = CreateIndexMap(count, 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) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: partial primary key detected"); } #endif 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) } 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 (schemaRow.IsAutoIncrement && IsAutoIncrementType(fieldType)) { // CONSIDER: use T-SQL "IDENT_INCR('table_or_view')" and "IDENT_SEED('table_or_view')" // functions to obtain the actual increment and seed values 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; } 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; } } } if (null == dataColumn.Table) { if (null == columnCollection) { columnCollection = dataTable.Columns; } 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[count]; } 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(count, unsortedIndex); columnIndexMap[unsortedIndex] = dataColumn.Ordinal; } mappingCount++; } bool addDataRelation = false; DataColumn chapterColumn = null; if (null != chapterValue) // add the extra column in the child table { DataColumnMapping columnMapping = tableMapping.GetColumnMappingBySchemaAction(tableMapping.SourceTable, mappingAction); if (null != columnMapping) { Type fieldType = chapterValue.GetType(); chapterColumn = columnMapping.GetDataColumnBySchemaAction(this.dataTable, fieldType, schemaAction); if (null != chapterColumn) { if (null == chapterColumn.Table) { chapterColumn.ReadOnly = true; // MDAC 71878 chapterColumn.AllowDBNull = false; if (null == columnCollection) { columnCollection = dataTable.Columns; } columnCollection.Add(chapterColumn); addDataRelation = (null != parentChapterColumn); } mappingCount++; } } } object[] dataValues = null; if (0 < mappingCount) { if ((null != this.dataSet) && null == this.dataTable.DataSet) { this.dataSet.Tables.Add(this.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 this.dataTable.PrimaryKey = keys; } else { UniqueConstraint unique = new UniqueConstraint("", keys); ConstraintCollection constraints = this.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 (gettingData) { if (null == columnCollection) { columnCollection = dataTable.Columns; } _indexMap = columnIndexMap; _chapterMap = chapterIndexMap; dataValues = SetupMapping(count, columnCollection, chapterColumn, chapterValue); } #if DEBUG else { this.mappedMode = -1; } #endif } else { this.dataTable = null; } if (addDataRelation) { AddRelation(parentChapterColumn, chapterColumn); } _readerDataValues = dataValues; }