/// <summary> /// This method prepares a new record for the trace table for a regular time step series. /// The method converts the given valueArray into the BLOB that is actually stored in /// the table. The method computes the checksum of the trace, and computes a new checksum /// for the parameters table to reflect the fact that a new trace has been added to the ensemble. /// For both the insertion to the trace table and the update to the parameters table, this method /// only stores changes in DataTable objects--nothing is changed in the database. In order for /// the changes to be sent to the database, the method TSConnection.CommitNewTraceWrites must /// be called after WriteTraceRegular has been called for all new traces. /// </summary> /// <param name="id">identifying primary key value of the the parameters table for the record /// that this trace belongs to</param> /// <param name="doWriteToDB">true if the method should actually save the timeseries to the database</param> /// <param name="tsImport">TSImport object into which the method will record values that it has computed. /// If this parameter is null, then the method will skip the recording of such paramters to an object.</param> /// <param name="traceNumber">number of the trace to write</param> /// <param name="valueArray">The array of values to be written to the database</param> public unsafe void WriteTraceRegular(int id, bool doWriteToDB, TSImport tsImport, int traceNumber, double[] valueArray) { // Initialize class fields other than the BLOB of data values if (!IsInitialized) { Initialize(id, true); } // This method can only process regular-time-step series if (TimeStepUnit == TSDateCalculator.TimeStepUnitCode.Irregular) { throw new TSLibraryException(ErrCode.Enum.Record_Not_Regular, String.Format("The method can only process regular time series, but" + "the record with Id {0} is irregular.", id)); } // Create a trace object int timeStepCount = valueArray.Count(); ITimeSeriesTrace traceObject = new TSTrace { TraceNumber = traceNumber, TimeStepCount = timeStepCount, EndDate = TSDateCalculator.IncrementDate(BlobStartDate, TimeStepUnit, TimeStepQuantity, timeStepCount - 1) }; if (tsImport != null) { tsImport.TraceList.Add(traceObject); } else { TraceList.Add(traceObject); } // Convert the array of double values into a byte array...a BLOB TSBlobCoder.ConvertArrayToBlobRegular(valueArray, CompressionCode, traceObject); // Create a new record for the trace table // (but for now it is only stored in a DataTable object) if (doWriteToDB) { WriteTrace(traceObject); } // Compute a new checksum for the parameters table // (but for now it is only stored in a DataTable object) UpdateParametersChecksum(doWriteToDB, tsImport); }
void ChecksumTimer() { int i; var ts = new TSParameters { BlobStartDate = DateTime.Parse("1/1/2000"), CompressionCode = TSBlobCoder.currentCompressionCode, TimeStepQuantity = 2, TimeStepUnit = TSDateCalculator.TimeStepUnitCode.Day }; var traces = new List<ITimeSeriesTrace>(); for (int traceIndex = 0; traceIndex < 80; traceIndex++) { var iterList = new List<double>(); for (int stepIndex = 0; stepIndex < nVals; stepIndex++) { iterList.Add(1.5 * stepIndex + 0.3373); } var trace = new TSTrace { TraceNumber = traceIndex + 1 }; trace.ValueBlob = TSBlobCoder.ConvertArrayToBlobRegular(iterList.ToArray(), TSBlobCoder.currentCompressionCode, trace); //trace.Checksum = new Guid().ToByteArray(); traces.Add(trace); } // Start the timer DateTime timerStart = DateTime.Now; // Create dummy time series that we can write to the database for (i = 0; i < nIter; i++) { foreach(var trace in traces) { TSBlobCoder.ComputeTraceChecksum(trace.TraceNumber, trace.ValueBlob); } TSBlobCoder.ComputeChecksum(ts, traces); } // Stop the timer DateTime timerEnd = DateTime.Now; TimeSpan timerDiff = timerEnd - timerStart; TimeLabelBlob.Content = String.Format("BLOBWRI --- Iterations: {0}; Duration: {1:hh\\:mm\\:ss\\.f}", i, timerDiff); }
public void ChecksumDiffTest1() { List<TimeSeriesValue> duplicateList = new List<TimeSeriesValue>(); // Create an identical array by deep copy foreach (TimeSeriesValue tsv in IrregList1) { duplicateList.Add(new TimeSeriesValue { Date = tsv.Date, Value = tsv.Value }); } // Slightly alter one date in the list duplicateList[5].Date = duplicateList[5].Date.AddMinutes(12); TSTrace trace1 = new TSTrace { TraceNumber = 1 }; TSTrace trace2 = new TSTrace { TraceNumber = 1 }; Boolean ret = ComputeTestChecksums( TSDateCalculator.TimeStepUnitCode.Irregular, 0, IrregList1, trace1, TSDateCalculator.TimeStepUnitCode.Irregular, 0, duplicateList, trace2); Assert.IsFalse(ret); }
public List<ITimeSeriesTrace> Get3TracesRegular( TSDateCalculator.TimeStepUnitCode u1, short q1, int c1, DateTime sDate1, out DateTime eDate1, Boolean shouldPerturb = false, int perturbTraceIndex = 0, int perturbStep = 0, double perturbVal = 0, double perturbMinutes = 0) { eDate1 = DateTime.Now; // dummy TSLibrary tsLib = new TSLibrary(); List<ITimeSeriesTrace> traceList = new List<ITimeSeriesTrace>(); int compressionCode; for (int t = 0; t < 3; t++) { TSTrace trace1 = new TSTrace { TraceNumber = t + 1 }; List<TimeSeriesValue> tsValues = new List<TimeSeriesValue>(); DateTime curDate = sDate1; Double curVal = 20; for (int i = 0; i < c1; i++) { tsValues.Add(new TimeSeriesValue { Date = curDate, Value = curVal }); curDate = tsLib.IncrementDate(curDate, u1, q1, 1); curVal = curVal + i / (t + 1); } // make a perturbation if called for if (shouldPerturb && t==perturbTraceIndex) { tsValues[perturbStep].Value += perturbVal; tsValues[perturbStep].Date = tsValues[perturbStep].Date.AddMinutes(perturbMinutes); } eDate1 = tsValues.Last().Date; tsLib.ConvertListToBlobWithChecksum( u1, q1, c1, sDate1, eDate1, tsValues, trace1, out compressionCode); traceList.Add(trace1); } return traceList; }
public void ConvertListToBlobWithChecksum_Err4() { TSLibrary tsLib = new TSLibrary(); TSTrace traceObject = new TSTrace { TraceNumber = 1 }; int compressionCode; try { byte[] blobData = tsLib.ConvertListToBlobWithChecksum( TSDateCalculator.TimeStepUnitCode.Irregular, 0, IrregList1.Count, IrregList1.First().Date, IrregList1.Last().Date.AddDays(2), IrregList1, traceObject, out compressionCode); Assert.Fail("Should have thrown exception"); } catch (TSLibraryException e) { Assert.AreEqual(ErrCode.Enum.Checksum_Improper_EndDate, e.ErrCode); } }
public void ConvertListToBlobWithChecksum_Err0() { TSLibrary tsLib = new TSLibrary(); TSTrace traceObject = new TSTrace { TraceNumber = 1 }; int compressionCode; try { byte[] blobData = tsLib.ConvertListToBlobWithChecksum( TSDateCalculator.TimeStepUnitCode.Irregular, 0, IrregList1.Count, IrregList1.First().Date, IrregList1.Last().Date, IrregList1, traceObject, out compressionCode); Assert.IsTrue(true); } catch (TSLibraryException) { Assert.Fail("Should not throw any exceptions"); } }
public void ComputeChecksum_Err1() { TSLibrary tsLib = new TSLibrary(); TSTrace traceObject = new TSTrace { TraceNumber = 1 }; try { byte[] blobData = tsLib.ComputeChecksum( TSDateCalculator.TimeStepUnitCode.Irregular, 3, IrregList1.First().Date, new List<ITimeSeriesTrace>()); Assert.Fail("Should have thrown exception"); } catch (TSLibraryException e) { Assert.AreEqual(ErrCode.Enum.Checksum_Quantity_Nonzero, e.ErrCode); } }
public void ChecksumIdenticalReg() { List<TimeSeriesValue> duplicateList = new List<TimeSeriesValue>(); // Create an identical array by deep copy foreach (TimeSeriesValue tsv in IrregList1) { duplicateList.Add(new TimeSeriesValue { Date = tsv.Date, Value = tsv.Value }); } TSTrace trace1 = new TSTrace { TraceNumber = 1 }; TSTrace trace2 = new TSTrace { TraceNumber = 1 }; Boolean ret = ComputeTestChecksums( TSDateCalculator.TimeStepUnitCode.Irregular, 0, IrregList1, trace1, TSDateCalculator.TimeStepUnitCode.Irregular, 0, duplicateList, trace2); Assert.IsTrue(ret); }
public void ChecksumDiffTest4() { List<TimeSeriesValue> duplicateList = new List<TimeSeriesValue>(); // Create an identical array by deep copy foreach (TimeSeriesValue tsv in IrregList1) { duplicateList.Add(new TimeSeriesValue { Date = tsv.Date, Value = tsv.Value }); } // remove a value from the middle of the list duplicateList.RemoveAt(150); TSTrace trace1 = new TSTrace { TraceNumber = 1 }; TSTrace trace2 = new TSTrace { TraceNumber = 1 }; Boolean ret = ComputeTestChecksums( TSDateCalculator.TimeStepUnitCode.Irregular, 0, IrregList1, trace1, TSDateCalculator.TimeStepUnitCode.Irregular, 0, duplicateList, trace2); Assert.IsFalse(ret); }
public void Test(Boolean inBulk, Boolean doParam) { // Create dummy time series that we can write to the database var valList = new List<double[]>(); for (int i = 0; i < nIter; i++) { var iterList = new List<double>(); for (int t = 0; t < nVals; t++) { iterList.Add(1.5 * t + i + 0.33); } valList.Add(iterList.ToArray()); } if (inBulk) { var traceObjects = new List<ITimeSeriesTrace>(); for (int i = 0; i < nIter; i++) { ITimeSeriesTrace traceObject = new TSTrace { TraceNumber = 1 }; // Convert the array of double values into a byte array...a BLOB traceObject.ValueBlob = TSBlobCoder.ConvertArrayToBlobRegular (valList[i], TSBlobCoder.currentCompressionCode, traceObject); traceObjects.Add(traceObject); } WriteBulkTraces(traceObjects); } else if (doParam) { // reference: http://stackoverflow.com/questions/2449827/pros-and-cons-of-using-sqlcommand-prepare-in-c // this does appear to be faster!! SqlCommand cmd = new SqlCommand("INSERT INTO " + TableName + "(TimeSeries_Id, TraceNumber, ValueBlob, Checksum) " + "VALUES (@TimeSeries_Id, @TraceNumber, @ValueBlob, @Checksum)", Connx); cmd.Parameters.Add("@TimeSeries_Id", SqlDbType.Int); cmd.Parameters.Add("@TraceNumber", SqlDbType.Int); cmd.Parameters.Add("@ValueBlob", SqlDbType.VarBinary, -1); cmd.Parameters.Add("@Checksum", SqlDbType.Binary, 16); cmd.Prepare(); SqlCommand selectCmd = new SqlCommand("SELECT TraceNumber, Checksum from " + TableName + " where TimeSeries_Id=@TimeSeries_Id order by TraceNumber", Connx); selectCmd.Parameters.Add("@TimeSeries_Id", SqlDbType.Int); selectCmd.Prepare(); SqlCommand updateCmd = new SqlCommand("UPDATE " + "OutputTimeSeries" + " SET Checksum=@Checksum WHERE Id=@Id", Connx); updateCmd.Parameters.Add("@Checksum", SqlDbType.Binary, 16); updateCmd.Parameters.Add("@Id", SqlDbType.Int); updateCmd.Prepare(); for (int i = 0; i < nIter; i++) { ITimeSeriesTrace traceObject = new TSTrace { TraceNumber = 1 }; // Convert the array of double values into a byte array...a BLOB traceObject.ValueBlob = TSBlobCoder.ConvertArrayToBlobRegular (valList[i], TSBlobCoder.currentCompressionCode, traceObject); WriteOneTraceParam(i + 1, traceObject, cmd); // update the checksum in the parameters table UpdateParametersChecksum(i + 1, selectCmd, updateCmd); } } else { for (int i = 0; i < nIter; i++) { ITimeSeriesTrace traceObject = new TSTrace { TraceNumber = 1 }; // Convert the array of double values into a byte array...a BLOB traceObject.ValueBlob = TSBlobCoder.ConvertArrayToBlobRegular (valList[i], TSBlobCoder.currentCompressionCode, traceObject); WriteOneTrace(traceObject); } } }