private bool SqlTrySelect(string chromatogramID, out Chromatogram chromatogram)
{
SQLiteCommand cmd;
if (!currentScope.TryGetCommand("SELECT_CHROMATOGRAM_CMD", out cmd))
{
cmd = currentScope.PrepareCommand("SELECT_CHROMATOGRAM_CMD", "SELECT Description FROM Chromatogram WHERE ChromatogramID = @chromatogramID");
}
else
{
cmd.Parameters.Clear();
}
cmd.Parameters.AddWithValue("@chromatogramID", chromatogramID);
string desc = cmd.ExecuteScalar() as string;
if (desc != null)
{
chromatogram = MzLiteJson.FromJson <Chromatogram>(desc);
return(true);
}
else
{
chromatogram = null;
return(false);
}
}
public ThermoRawFileReader(string rawFilePath)
{
this.rawFilePath = rawFilePath;
if (string.IsNullOrWhiteSpace(rawFilePath))
{
throw new ArgumentNullException("rawFilePath");
}
if (!File.Exists(rawFilePath))
{
throw new FileNotFoundException("Raw file not exists.");
}
try
{
rawFile = new MSFileReader_XRawfile() as IXRawfile5;
rawFile.Open(rawFilePath);
rawFile.SetCurrentController(0, 1);
startScanNo = GetFirstSpectrumNumber(rawFile);
endScanNo = GetLastSpectrumNumber(rawFile);
model = MzLiteJson.HandleExternalModelFile(this, GetModelFilePath());
}
catch (Exception ex)
{
throw new MzLiteIOException(ex.Message, ex);
}
}
private bool SqlTrySelect(string chromatogramID, out Peak2DArray peaks)
{
SQLiteCommand cmd;
if (!currentScope.TryGetCommand("SELECT_CHROMATOGRAM_PEAKS_CMD", out cmd))
{
cmd = currentScope.PrepareCommand("SELECT_CHROMATOGRAM_PEAKS_CMD", "SELECT PeakArray, PeakData FROM Chromatogram WHERE ChromatogramID = @chromatogramID");
}
else
{
cmd.Parameters.Clear();
}
cmd.Parameters.AddWithValue("@chromatogramID", chromatogramID);
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
peaks = MzLiteJson.FromJson <Peak2DArray>(reader.GetString(0));
decoder.Decode(reader.GetStream(1), peaks);
return(true);
}
else
{
peaks = null;
return(false);
}
}
}
private bool SqlTrySelect(string spectrumID, out MassSpectrum ms)
{
SQLiteCommand cmd;
if (!currentScope.TryGetCommand("SELECT_SPECTRUM_CMD", out cmd))
{
cmd = currentScope.PrepareCommand("SELECT_SPECTRUM_CMD", "SELECT Description FROM Spectrum WHERE SpectrumID = @spectrumID");
}
else
{
cmd.Parameters.Clear();
}
cmd.Parameters.AddWithValue("@spectrumID", spectrumID);
string desc = cmd.ExecuteScalar() as string;
if (desc != null)
{
ms = MzLiteJson.FromJson <MassSpectrum>(desc);
return(true);
}
else
{
ms = null;
return(false);
}
}
public WiffFileReader(string wiffFilePath, string licenseFilePath)
{
if (string.IsNullOrWhiteSpace(wiffFilePath))
{
throw new ArgumentNullException("wiffFilePath");
}
if (string.IsNullOrWhiteSpace(licenseFilePath))
{
throw new ArgumentNullException("licenseFilePath");
}
if (!File.Exists(wiffFilePath))
{
throw new FileNotFoundException("Wiff file not exists.");
}
try
{
ReadWiffLicense(licenseFilePath);
this.dataProvider = new AnalystWiffDataProvider(true);
this.batch = AnalystDataProviderFactory.CreateBatch(wiffFilePath, dataProvider);
this.wiffFilePath = wiffFilePath;
this.model = MzLiteJson.HandleExternalModelFile(this, GetModelFilePath());
}
catch (Exception ex)
{
throw new MzLiteIOException(ex.Message, ex);
}
}
public BafFileReader(string bafFilePath)
{
if (string.IsNullOrWhiteSpace(bafFilePath))
{
throw new ArgumentNullException("bafFilePath");
}
if (!File.Exists(bafFilePath))
{
throw new FileNotFoundException("Baf file not exists.");
}
this.bafFilePath = bafFilePath;
try
{
sqlFilePath = Baf2SqlWrapper.GetSQLiteCacheFilename(bafFilePath);
// First argument = 1, ignore contents of Calibrator.ami (if it exists)
baf2SqlHandle = Baf2SqlWrapper.baf2sql_array_open_storage(1, bafFilePath);
if (baf2SqlHandle == 0)
{
Baf2SqlWrapper.ThrowLastBaf2SqlError();
}
linq2BafSql = new Linq2BafSql(sqlFilePath);
model = MzLiteJson.HandleExternalModelFile(this, GetModelFilePath());
supportedVariables = SupportedVariablesCollection.ReadSupportedVariables(linq2BafSql);
}
catch (Exception ex)
{
throw new MzLiteIOException(ex.Message, ex);
}
}
static void WiffToSQLite()
{
string wiffPath = @"C:\Work\primaqdev\testdata\C2 Sol SWATH4.wiff";
string mzLitePath = Path.Combine(Path.GetDirectoryName(wiffPath), Path.GetFileNameWithoutExtension(wiffPath) + ".mzlite");
string runID = "sample=0";
if (File.Exists(mzLitePath))
{
File.Delete(mzLitePath);
}
using (IMzLiteDataReader reader = new WiffFileReader(wiffPath))
using (ITransactionScope inTxn = reader.BeginTransaction())
using (MzLiteSQL writer = new MzLiteSQL(mzLitePath))
using (ITransactionScope outTxn = writer.BeginTransaction())
{
foreach (var ms in reader.ReadMassSpectra(runID))
{
var peaks = reader.ReadSpectrumPeaks(ms.ID);
var clonedMS = MzLiteJson.JsonCloneModelItem("#1", ms);
writer.Insert(runID, clonedMS, peaks);
break;
}
foreach (var ms in writer.ReadMassSpectra(runID))
{
var peaks = writer.ReadSpectrumPeaks(ms.ID);
var ms1 = writer.ReadMassSpectrum(ms.ID);
break;
}
outTxn.Commit();
}
}
public void SaveModel()
{
RaiseDisposed();
try
{
MzLiteJson.SaveJsonFile(model, GetModelFilePath());
}
catch (Exception ex)
{
throw new MzLiteIOException(ex.Message, ex);
}
}
private void SqlSave(MzLiteModel model)
{
using (SQLiteCommand cmd = currentScope.CreateCommand("DELETE FROM Model"))
{
cmd.ExecuteNonQuery();
}
using (SQLiteCommand cmd = currentScope.CreateCommand("INSERT INTO Model VALUES(@lock, @content)"))
{
cmd.Parameters.AddWithValue("@lock", 0);
cmd.Parameters.AddWithValue("@content", MzLiteJson.ToJson(model));
cmd.ExecuteNonQuery();
}
}
private IEnumerable <Chromatogram> SqlSelectChromatograms(string runID)
{
using (SQLiteCommand cmd = currentScope.CreateCommand("SELECT Description FROM Chromatogram WHERE RunID = @runID"))
{
cmd.Parameters.AddWithValue("@runID", runID);
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
yield return(MzLiteJson.FromJson <Chromatogram>(reader.GetString(0)));
}
}
}
}
private bool SqlTrySelect(out MzLiteModel model)
{
using (SQLiteCommand cmd = currentScope.CreateCommand("SELECT Content FROM Model"))
{
string content = cmd.ExecuteScalar() as string;
if (content != null)
{
model = MzLiteJson.FromJson <MzLiteModel>(content);
return(true);
}
else
{
model = null;
return(false);
}
}
}
private void SqlInsert(string runID, Chromatogram chromatogram, Peak2DArray peaks)
{
SQLiteCommand cmd;
if (!currentScope.TryGetCommand("INSERT_CHROMATOGRAM_CMD", out cmd))
{
cmd = currentScope.PrepareCommand("INSERT_CHROMATOGRAM_CMD", "INSERT INTO Chromatogram VALUES(@runID, @chromatogramID, @description, @peakArray, @peakData);");
}
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@runID", runID);
cmd.Parameters.AddWithValue("@chromatogramID", chromatogram.ID);
cmd.Parameters.AddWithValue("@description", MzLiteJson.ToJson(chromatogram));
cmd.Parameters.AddWithValue("@peakArray", MzLiteJson.ToJson(peaks));
cmd.Parameters.AddWithValue("@peakData", encoder.Encode(peaks));
cmd.ExecuteNonQuery();
}
private void SqlInsert(string runID, MassSpectrum spectrum, Peak1DArray peaks)
{
SQLiteCommand cmd;
if (!currentScope.TryGetCommand("INSERT_SPECTRUM_CMD", out cmd))
{
cmd = currentScope.PrepareCommand("INSERT_SPECTRUM_CMD", "INSERT INTO Spectrum VALUES(@runID, @spectrumID, @description, @peakArray, @peakData);");
}
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@runID", runID);
cmd.Parameters.AddWithValue("@spectrumID", spectrum.ID);
cmd.Parameters.AddWithValue("@description", MzLiteJson.ToJson(spectrum));
cmd.Parameters.AddWithValue("@peakArray", MzLiteJson.ToJson(peaks));
cmd.Parameters.AddWithValue("@peakData", encoder.Encode(peaks));
cmd.ExecuteNonQuery();
}
