/// <summary> /// Initializes a new instance of the <see cref="ObjectRecord" /> class. /// </summary> /// <param name="recordSetDefinition">The table definition.</param> /// <param name="randomData">if set to <see langword="true" /> fills columns with random data; otherwise fills them with their default values.</param> /// <param name="nullProbability">The probability of a column's value being set to SQL null (0.0 for no nulls) - /// this is only applicable is <paramref name="randomData" /> is set to <see langword="true" /> [Defaults to 0.1 = 10%].</param> /// <param name="columnGenerators">The column generators is an array of functions that generate a value for each column, if the function is /// <see langword="null" /> for a particular index then a random value is generated, if it is not null then the function is used. The function takes /// the current row number as it's only parameter and must return an object of the correct type for the column.</param> /// <param name="rowNumber">The optional row number to pass to the generator.</param> /// <exception cref="System.ArgumentException">Thrown if the number of column generators exceeds the number of columns in the record set definition.</exception> public ObjectRecord( [NotNull] RecordSetDefinition recordSetDefinition, bool randomData = false, double nullProbability = 0.1, [CanBeNull] Func<int, object>[] columnGenerators = null, int rowNumber = 1) { if (recordSetDefinition == null) throw new ArgumentNullException("recordSetDefinition"); _recordSetDefinition = recordSetDefinition; int columnCount = recordSetDefinition.FieldCount; _columnValues = new object[columnCount]; if ((columnGenerators != null) && (columnGenerators.Length > recordSetDefinition.FieldCount)) throw new ArgumentException( "The number of column generators must not exceed the number of columns in the record set definition.", "columnGenerators"); for (int c = 0; c < columnCount; c++) // Check if we have a generator if ((columnGenerators != null) && (columnGenerators.Length > c) && (columnGenerators[c] != null)) // Use generator to get value this[c] = columnGenerators[c](rowNumber); else if (randomData) // Generate random value. this[c] = recordSetDefinition[c].GetRandomValue(nullProbability); else // Just set to default value (no need to revalidate so set directly). _columnValues[c] = recordSetDefinition[c].DefaultValue; }
/// <summary> /// Initializes a new instance of the <see cref="ObjectRecord" /> class. /// </summary> /// <param name="recordSetDefinition">The table definition.</param> /// <param name="randomData">if set to <see langword="true" /> fills columns with random data; otherwise fills them with their default values.</param> /// <param name="nullProbability">The probability of a column's value being set to SQL null (0.0 for no nulls) - /// this is only applicable is <paramref name="randomData" /> is set to <see langword="true" /> [Defaults to 0.1 = 10%].</param> /// <param name="columnGenerators">The column generators is an array of functions that generate a value for each column, if the function is /// <see langword="null" /> for a particular index then a random value is generated, if it is not null then the function is used. The function takes /// the current row number as it's only parameter and must return an object of the correct type for the column.</param> /// <param name="rowNumber">The optional row number to pass to the generator.</param> /// <exception cref="System.ArgumentException">Thrown if the number of column generators exceeds the number of columns in the record set definition.</exception> public ObjectRecord( [NotNull] RecordSetDefinition recordSetDefinition, bool randomData = false, double nullProbability = 0.1, [CanBeNull] Func <int, object>[] columnGenerators = null, int rowNumber = 1) { if (recordSetDefinition == null) { throw new ArgumentNullException("recordSetDefinition"); } _recordSetDefinition = recordSetDefinition; int columnCount = recordSetDefinition.FieldCount; _columnValues = new object[columnCount]; if ((columnGenerators != null) && (columnGenerators.Length > recordSetDefinition.FieldCount)) { throw new ArgumentException( "The number of column generators must not exceed the number of columns in the record set definition.", "columnGenerators"); } for (int c = 0; c < columnCount; c++) { // Check if we have a generator if ((columnGenerators != null) && (columnGenerators.Length > c) && (columnGenerators[c] != null)) { // Use generator to get value this[c] = columnGenerators[c](rowNumber); } else if (randomData) { // Generate random value. this[c] = recordSetDefinition[c].GetRandomValue(nullProbability); } else { // Just set to default value (no need to revalidate so set directly). _columnValues[c] = recordSetDefinition[c].DefaultValue; } } }
private static IEnumerable <IObjectRecord> GenerateRecords( [NotNull] RecordSetDefinition recordSetDefinition, int minRows, int maxRows, double nullProbability, [CanBeNull] Func <int, object>[] columnGenerators = null) { if (recordSetDefinition == null) { throw new ArgumentNullException("recordSetDefinition"); } if (minRows < 0) { throw new ArgumentOutOfRangeException("minRows"); } if (maxRows < 0) { throw new ArgumentOutOfRangeException("maxRows"); } if (minRows > maxRows) { throw new ArgumentOutOfRangeException("maxRows"); } // Calculate number of rows. int rows = minRows == maxRows ? minRows : Tester.RandomGenerator.Next(minRows, maxRows); if (rows < 1) { return(Enumerable.Empty <IObjectRecord>()); } // Create random records List <IObjectRecord> records = new List <IObjectRecord>(); for (int r = 0; r < rows; r++) { records.Add(new ObjectRecord(recordSetDefinition, true, nullProbability, columnGenerators, r + 1)); } return(records); }
/// <summary> /// Initializes a new instance of the <see cref="ObjectSet" /> class. /// </summary> /// <param name="recordSetDefinition">The record set definition.</param> /// <param name="records">The records.</param> /// <remarks></remarks> public ObjectSet([NotNull] RecordSetDefinition recordSetDefinition, IEnumerable <IObjectRecord> records = null) { if (recordSetDefinition == null) { throw new ArgumentNullException("recordSetDefinition"); } _definition = recordSetDefinition; if (records == null) { return; } foreach (IObjectRecord record in records) { Add(record); } }
/// <summary> /// Initializes a new instance of the <see cref="ObjectRecord" /> class. /// </summary> /// <param name="recordSetDefinition">The table definition.</param> /// <param name="columnValues">The column values.</param> /// <remarks> /// If the number of column values supplied is less than the number of columns then the remaining columns are set to /// their equivalent default value. /// </remarks> public ObjectRecord([NotNull] RecordSetDefinition recordSetDefinition, [NotNull] params object[] columnValues) { if (recordSetDefinition == null) throw new ArgumentNullException("recordSetDefinition"); if (columnValues == null) throw new ArgumentNullException("columnValues"); int length = columnValues.Length; int columns = recordSetDefinition.FieldCount; if (length > columns) throw new ArgumentException( string.Format( "The number of values specified '{0}' cannot exceed the number of expected columns '{1}'.", length, columns), "columnValues"); _recordSetDefinition = recordSetDefinition; _columnValues = new object[recordSetDefinition.FieldCount]; // Import values or set to null. for (int i = 0; i < columns; i++) SetValue(i, i < length ? columnValues[i] : _recordSetDefinition[i].DefaultValue); }
public void RecordExample() { // To create a record that implement IDataRecord we start with a record set definition. RecordSetDefinition recordSetDefinition = new RecordSetDefinition( new ColumnDefinition("ID", SqlDbType.Int), new ColumnDefinition("Name", SqlDbType.Char, 50), new ColumnDefinition("Description", SqlDbType.NVarChar), // This column is not nullable so defaults to true new ColumnDefinition("Active", SqlDbType.Bit, isNullable: false, defaultValue: true) ); // Now we can create a record IObjectRecord dataRecord = new ObjectRecord(recordSetDefinition, 1, "Test", "This is my test record"); // Or we can create one with random values IObjectRecord randomRecord = new ObjectRecord(recordSetDefinition, true); // To create a record that throws an exception we first create a SqlException // We can't do this directly, but we can use our prototypes to construct one. // SqlExceptions are made from a collection of SqlErrors - which can make like this : SqlErrorCollection errorCollection = new SqlErrorCollectionPrototype { new SqlErrorPrototype( 1000, 80, 17, "MyFakeServer", "Connection Timeout.", "spMySproc", 54) }; SqlException sqlException = new SqlExceptionPrototype(errorCollection, "9.0.0.0", Guid.NewGuid()); IObjectRecord exceptionRecord = new ExceptionRecord(sqlException); // We can stick these records into a recordset // Note the records must have the same RecordSetDefinition (unless it's an exception record) // The final record will through an exception when reached! ObjectSet recordSet = new ObjectSet(recordSetDefinition) { dataRecord, randomRecord, //exceptionRecord }; // We can add recordsets to an ObjectReader ObjectReader reader = new ObjectReader { recordSet }; // We can also add random record sets - this one has the same definition as the first. reader.Add(new RandomSet(recordSetDefinition)); // We can also fix certain rows values using the column generators arry, a null indicates // that the column should us a random value, otherwise a lambda can be supplied - in this case // it sets the row to the row number (1 - indexed). reader.Add( new RandomSet( recordSetDefinition, columnGenerators: new Func<int, object>[] { null, row => "Row #" + row })); // Whereas this one has a random set of columns (with random types). reader.Add(new RandomSet(10)); // Now that we have a reader we can use it like a normal reader - it even simulates disposal. using (IDataReader dataReader = reader) { int recordset = 1; do { Trace.Write("Recordset #" + recordset); int rows = 0; while (dataReader.Read()) rows++; Trace.WriteLine(" - " + rows + " rows."); recordset++; } while (dataReader.NextResult()); } }
public void TestCustomException() { // To create a record that implement IDataRecord we start with a record set definition. RecordSetDefinition recordSetDefinition = new RecordSetDefinition( new ColumnDefinition("ID", SqlDbType.Int), new ColumnDefinition("Name", SqlDbType.Char, 50), new ColumnDefinition("Description", SqlDbType.NVarChar), // This column is not nullable so defaults to true new ColumnDefinition("Active", SqlDbType.Bit, isNullable: false, defaultValue: true) ); // Now we can create a record IObjectRecord dataRecord = new ObjectRecord(recordSetDefinition, 1, "Test", "This is my test record"); // To create a record that throws an exception we first create an ExceptionRecord IObjectRecord exceptionRecord = new ExceptionRecord(new SqlInvalidSyntaxException()); // We can stick these records into a recordset // Note the records must have the same RecordSetDefinition (unless it's an exception record) // The final record will through an exception when reached! ObjectSet recordSet = new ObjectSet(recordSetDefinition) { dataRecord, exceptionRecord }; // We can add recordsets to an ObjectReader ObjectReader reader = new ObjectReader { recordSet }; // Now that we have a reader we can use it like a normal reader - it even simulates disposal. ReadFromRecordSet(reader); }