/// <summary>
        /// Main processing script.
        /// </summary>
        /// <param name="input">The input row.</param>
        /// <param name="outputRow">The output row.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>The IEnumerable output row.</returns>
        public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
        {
            string frameShift = args[0];
            string frameLength = args[1];

            Directory.CreateDirectory("relatedFeatures");

            foreach (var row in input.Rows)
            {
                outputRow["WaveID"].Set(row["WaveID"].String);
                outputRow["WaveBinary"].Set(row["WaveBinary"].Binary);
                outputRow["WaveAlignments"].Set(row["WaveAlignments"].String);
                outputRow["RawF0"].Set(row["RawF0"].String);
                outputRow["LPCC"].Set(row["LPCC"].Binary);
                outputRow["OF0"].Set(row["OF0"].String);
                outputRow["LSP"].Set(row["LSP"].Binary);
                outputRow["Pow"].Set(row["Pow"].String);
                outputRow["MBE"].Set(row["MBE"].String);
                outputRow["NCCF"].Set(row["NCCF"].String);

                string waveId = row["WaveID"].String;
                string wave = JobBase.GenerateLocalFile(waveId, row["WaveBinary"].Binary, FileExtensions.Waveform);

                string relatedFeatureFile = Path.Combine("relatedFeatures", waveId + "." + FileExtensions.Text);
                string[] argument = { wave, relatedFeatureFile, frameShift, frameLength };
                F0ExtractorCOSMOS.ExtractRelatedFeaturesOneFile(argument, null);

                outputRow["RF"].Set(File.ReadAllText(relatedFeatureFile));
                yield return outputRow;
            }
        }

 internal static void valueComparator(RowSet rawrowset, List<object[]> insertedRows)
 {
     List<Row> rowset = rawrowset.GetRows().ToList();
     Assert.True(rowset.Count == insertedRows.Count,
                 string.Format(
                     "Returned rows count is not equal with the count of rows that were inserted! \n Returned: {0} \n Expected: {1} \n",
                     rowset.Count, insertedRows.Count));
     int i = 0;
     foreach (Row row in rowset)
     {
         if (row.Any(col => col.GetType() == typeof (byte[])))
             for (int j = 0; j < row.Length; j++)
             {
                 Assert.AreEqual(insertedRows[i][j], row[j]);
             }
         else
         {
             for (int m = 0; m < row.Length; m++)
             {
                 if (!row[m].Equals(insertedRows[i][m]))
                 {
                     insertedRows.Reverse(); // To check if needed and why 
                     if (!row[m].Equals(insertedRows[i][m]))
                         insertedRows.Reverse();
                 }
                 Assert.AreEqual(insertedRows[i][m], row[m], "Inserted data does not match with returned data.");
             }
         }
         i++;
     }
 }

 /// <summary>
 /// Creates a rowset.
 /// The columns are named: col_0, ..., col_n
 /// The rows values are: row_0_col_0, ..., row_m_col_n
 /// </summary>
 public RowSet CreateStringsRowset(int columnLength, int rowLength, string valueModifier = null)
 {
     var columns = new List<CqlColumn>();
     var columnIndexes = new Dictionary<string, int>();
     for (var i = 0; i < columnLength; i++)
     {
         var c = new CqlColumn()
         {
             Index = i,
             Name = "col_" + i,
             TypeCode = ColumnTypeCode.Text,
             Type = typeof(string)
         };
         columns.Add(c);
         columnIndexes.Add(c.Name, c.Index);
     }
     var rs = new RowSet();
     for (var j = 0; j < rowLength; j++)
     {
         var rowValues = new List<byte[]>();
         foreach (var c in columns)
         {
             var value = valueModifier + "row_" + j + "_col_" + c.Index;
             rowValues.Add(Encoding.UTF8.GetBytes(value));
         }
         rs.AddRow(new Row(1, rowValues.ToArray(), columns.ToArray(), columnIndexes));
     }
     return rs;
 }

        /// <summary>
        /// Main processing script.
        /// </summary>
        /// <param name="input">The input row.</param>
        /// <param name="outputRow">The output row.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>The IEnumerable output row.</returns>
        public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
        {
            string svmDir = "svm";
            string scaledSVMDir = "scaledSVM";
            Directory.CreateDirectory(svmDir);
            Directory.CreateDirectory(scaledSVMDir);

            foreach (var row in input.Rows)
            {
                outputRow["WaveID"].Set(row["WaveID"].String);
                outputRow["WaveBinary"].Set(row["WaveBinary"].Binary);
                outputRow["WaveAlignments"].Set(row["WaveAlignments"].String);
                outputRow["RawF0"].Set(row["RawF0"].String);
                outputRow["LPCC"].Set(row["LPCC"].Binary);
                outputRow["OF0"].Set(row["OF0"].String);
                outputRow["LSP"].Set(row["LSP"].Binary);
                outputRow["Pow"].Set(row["Pow"].String);
                outputRow["MBE"].Set(row["MBE"].String);

                string waveId = row["WaveID"].String;
                string svmFile = JobBase.GenerateLocalFile(waveId, row["SVM"].String, FileExtensions.Text, false, svmDir);
                string scaledSVMFile = Path.Combine(scaledSVMDir, waveId + "." + FileExtensions.Text);
                string svmRangeFile = Path.GetFileName(this.Job.ReplaceVariable["SVMRANGE"]);

                // File.WriteAllText(svmRangeFile, TmocFile.NormalizeOutput(svmRangeFile)).
                string argument = Helper.NeutralFormat(" -r \"{0}\" \"{1}\"", svmRangeFile, svmFile);
                DelayedLogger logger = new DelayedLogger(new TextLogger(scaledSVMFile));
                CommandLine.RunCommand(Path.GetFileName(this.Job.ReplaceVariable["SVMSCALETOOL"]),
                    argument, Environment.CurrentDirectory, logger.Writer, logger.Writer, null);
                logger.Dispose();
                outputRow["SSVM"].Set(File.ReadAllText(scaledSVMFile));

                yield return outputRow;
            }
        }

    public override IEnumerable<Row> Reduce(RowSet input, Row output, string[] args)
    {
        DateTime lastLogin = default(DateTime);
        int sessionId = 1;
        foreach (Row row in input.Rows)
        {
            DateTime currentLoginTime = (DateTime)row["logintime"].Value;
            if (lastLogin == default(DateTime))
            {
                lastLogin = currentLoginTime;
            }
            else
            {
                if (lastLogin.AddMinutes(30) < currentLoginTime)
                    sessionId++;

                lastLogin = currentLoginTime;
            }

            row.CopyTo(output);
            output["sessionId"].Set(sessionId);
            yield return output;

        }
    }

        /// <summary>
        /// Main processing script.
        /// </summary>
        /// <param name="input">The input row.</param>
        /// <param name="outputRow">The output row.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>The IEnumerable output row.</returns>
        public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
        {
            string uvDir = "uv";
            string scaledSVMDir = "scaledSVM";
            Directory.CreateDirectory(uvDir);
            Directory.CreateDirectory(scaledSVMDir);

            foreach (var row in input.Rows)
            {
                outputRow["WaveID"].Set(row["WaveID"].String);
                outputRow["WaveBinary"].Set(row["WaveBinary"].Binary);
                outputRow["WaveAlignments"].Set(row["WaveAlignments"].String);
                outputRow["RawF0"].Set(row["RawF0"].String);
                outputRow["LPCC"].Set(row["LPCC"].Binary);
                outputRow["OF0"].Set(row["OF0"].String);
                outputRow["LSP"].Set(row["LSP"].Binary);
                outputRow["Pow"].Set(row["Pow"].String);
                outputRow["MBE"].Set(row["MBE"].String);

                string waveId = row["WaveID"].String;
                string scaledSVMFile = JobBase.GenerateLocalFile(waveId, row["SSVM"].String, FileExtensions.Text, false, scaledSVMDir);
                string uvFile = Path.Combine(uvDir, waveId + "." + FileExtensions.Text);
                string argument = Helper.NeutralFormat(" \"{0}\" \"{1}\" \"{2}\"", scaledSVMFile, Path.GetFileName(this.Job.ReplaceVariable["UVMODELFILE"]), uvFile);

                CommandLine.RunCommand(Path.GetFileName(this.Job.ReplaceVariable["SVMPREDICTTOOL"]),
                    argument, "./");
                outputRow["UV"].Set(JobBase.GetTextFile(uvFile));
                yield return outputRow;
            }
        }

        /// <summary>
        /// Main processing script.
        /// </summary>
        /// <param name="input">The input row.</param>
        /// <param name="outputRow">The output row.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>The IEnumerable output row.</returns>
        public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
        {
            string f0Dir = "f0";
            string expandDir = "expand";
            string svmDir = "svm";
            Directory.CreateDirectory(f0Dir);
            Directory.CreateDirectory(expandDir);
            Directory.CreateDirectory(svmDir);

            foreach (var row in input.Rows)
            {
                outputRow["WaveID"].Set(row["WaveID"].String);
                outputRow["WaveBinary"].Set(row["WaveBinary"].Binary);
                outputRow["WaveAlignments"].Set(row["WaveAlignments"].String);
                outputRow["RawF0"].Set(row["RawF0"].String);
                outputRow["LPCC"].Set(row["LPCC"].Binary);
                outputRow["OF0"].Set(row["OF0"].String);
                outputRow["LSP"].Set(row["LSP"].Binary);
                outputRow["Pow"].Set(row["Pow"].String);
                outputRow["MBE"].Set(row["MBE"].String);

                string waveId = row["WaveID"].String;
                string f0File = JobBase.GenerateLocalFile(waveId, row["RawF0"].String, FileExtensions.F0File, true, f0Dir);
                string expandFeatureFile = JobBase.GenerateLocalFile(waveId, row["EXP"].String, FileExtensions.Text, false, expandDir);
                string svmFile = Path.Combine(svmDir, waveId + "." + FileExtensions.Text);

                string[] argument = { f0File, expandFeatureFile, svmFile };
                F0ExtractorCOSMOS.FormatFeaturesOneFile(argument, null);

                outputRow["SVM"].Set(File.ReadAllText(svmFile));
                yield return outputRow;
            }
        }

        /// <summary>
        /// Main processing script.
        /// </summary>
        /// <param name="input">The input row.</param>
        /// <param name="outputRow">The output row.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>The IEnumerable output row.</returns>
        public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
        {
            float minF0Value = float.Parse(args[0]);
            float maxF0Value = float.Parse(args[1]);
            string uvDir = "uv";
            string fZeroDir = "f0";
            string smoothedFZeroDir = "smoothedF0";

            Directory.CreateDirectory(uvDir);
            Directory.CreateDirectory(fZeroDir);
            Directory.CreateDirectory(smoothedFZeroDir);

            foreach (var row in input.Rows)
            {
                outputRow["WaveID"].Set(row["WaveID"].String);
                outputRow["WaveBinary"].Set(row["WaveBinary"].Binary);
                outputRow["WaveAlignments"].Set(row["WaveAlignments"].String);
                outputRow["RawF0"].Set(row["RawF0"].String);
                outputRow["LPCC"].Set(row["LPCC"].Binary);
                outputRow["OF0"].Set(row["OF0"].String);
                outputRow["LSP"].Set(row["LSP"].Binary);
                outputRow["Pow"].Set(row["Pow"].String);
                outputRow["MBE"].Set(row["MBE"].String);

                string waveId = row["WaveID"].String;
                string f0File = JobBase.GenerateLocalFile(waveId, row["RawF0"].String, FileExtensions.F0File, true, fZeroDir);
                string uvFile = JobBase.GenerateLocalFile(waveId, row["UV"].String, FileExtensions.Text, true, uvDir);
                string smoothedF0File = Path.Combine(smoothedFZeroDir, waveId + "." + FileExtensions.F0File);
                string[] argument = { f0File, uvFile, smoothedF0File, minF0Value.ToString(), maxF0Value.ToString() };
                F0ExtractorCOSMOS.SmoothOneF0File(argument, null);
                outputRow["SF0"].Set(JobBase.GetTextFile(smoothedF0File));
                yield return outputRow;
            }
        }

 internal CqlReader(RowSet rows)
 {
     popul = rows;
     for (int idx = 0; idx < popul.Columns.Length; idx++)
         colidx.Add(popul.Columns[idx].Name, idx);
     enumRows = popul.GetRows();
     enumerRows = enumRows.GetEnumerator();
 }

 private void AddDataToWorksheet(RowSet resultset, Excel.Range target, bool useFormula)
 {
     var rgTitles = target.Resize[1, resultset.ColLen];
     Utils.AddTitlesToRange(rgTitles, resultset.Titles);
     var rgData = ((Excel.Range)target.Cells[2, 1]).Resize[resultset.RowLen, resultset.ColLen];
     Utils.AddDataToRange(rgData, resultset.Data, useFormula);
     Utils.AddTagsToRange(rgData, resultset.Diff, ctrlInteriorColor.SelectedColor, ctrlFontColor.SelectedColor);
 }

 public void FetchAsync_Pocos_WithCql_Empty()
 {
     var rowset = new RowSet();
     var mappingClient = GetMappingClient(rowset);
     var userTask = mappingClient.FetchAsync<PlainUser>("SELECT * FROM users");
     var users = userTask.Result;
     Assert.NotNull(users);
     Assert.AreEqual(0, users.Count());
 }

        /// <summary>
        /// Main processing script.
        /// </summary>
        /// <param name="input">The input row.</param>
        /// <param name="outputRow">The output row.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>The IEnumerable output row.</returns>
        public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
        {
            foreach (var row in input.Rows)
            {
                outputRow["WaveID"].Set(row["WaveID"].String);
                outputRow["SVM"].Set(row["SVM"].String);

                yield return outputRow;
            }
        }

 private ISession GetSession(RowSet result)
 {
     var sessionMock = new Mock<ISession>(MockBehavior.Strict);
     sessionMock
         .Setup(s => s.ExecuteAsync(It.IsAny<IStatement>()))
         .Returns(TestHelper.DelayedTask(result, 200))
         .Verifiable();
     sessionMock.Setup(s => s.PrepareAsync(It.IsAny<string>())).Returns(TaskHelper.ToTask(GetPrepared("Mock query")));
     sessionMock.Setup(s => s.BinaryProtocolVersion).Returns(2);
     return sessionMock.Object;
 }

        public void CommandExecuteReaderUsesSyncExecute()
        {
            var connection = new CqlConnection();
            var sessionMock = new Mock<ISession>();
            var rowset = new RowSet();
            sessionMock
                .Setup(s => s.Execute(It.IsAny<string>(), It.IsAny<ConsistencyLevel>()))
                .Returns(rowset)
                .Verifiable();
            connection.ManagedConnection = sessionMock.Object;

            var cmd = (CqlCommand) connection.CreateCommand();
            cmd.CommandText = "INSERT INTO dummy_cf (a,b) VALUES (1,2)";
            var reader = cmd.ExecuteReader();
            reader.Dispose();
            sessionMock.Verify();
        }

 private void AddColumnInfoToWorksheet(RowSet resultset, Excel.Range target)
 {
     object[,] info = ExcelArray<object>.Create(resultset.RowLen, 1);
     var rgTitles = (Excel.Range)target.Rows[0];
     var rgInfo = (Excel.Range)target.Columns[0];
     for (int ri = 1; ri <= resultset.RowLen; ri++) {
         switch (resultset.Match[ri]) {
             case XlRowMatch.MatchWithDiff: info[ri, 1] = "'!="; break;
             case XlRowMatch.NoMatch: info[ri, 1] = "'+"; break;
         }
     }
     Utils.SetCellStyle(rgInfo, 0xFF);
     rgTitles.Value = resultset.Titles;
     rgTitles.Font.Bold = true;
     rgInfo.Value = info;
     rgInfo.HorizontalAlignment = Excel.Constants.xlCenter;
     rgInfo.ColumnWidth = 2.5;
 }

        /// <summary>
        /// Main processing script.
        /// </summary>
        /// <param name="input">The input row.</param>
        /// <param name="outputRow">The output row.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>The IEnumerable output row.</returns>
        public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
        {
            string frameShift = args[0];
            string frameLength = args[1];

            string waveDir = "wave";
            string lpcDir = "lpc";
            string residual0Dir = "residual";
            Directory.CreateDirectory(waveDir);
            Directory.CreateDirectory(lpcDir);
            Directory.CreateDirectory(residual0Dir);

            foreach (var row in input.Rows)
            {
                outputRow["WaveID"].Set(row["WaveID"].String);
                outputRow["WaveBinary"].Set(row["WaveBinary"].Binary);
                outputRow["WaveAlignments"].Set(row["WaveAlignments"].String);
                outputRow["RawF0"].Set(row["RawF0"].String);
                outputRow["LPCC"].Set(row["LPCC"].Binary);
                outputRow["OF0"].Set(row["OF0"].String);
                outputRow["LSP"].Set(row["LSP"].Binary);
                outputRow["Pow"].Set(row["Pow"].String);
                outputRow["MBE"].Set(row["MBE"].String);
                outputRow["NCCF"].Set(row["NCCF"].String);
                outputRow["RF"].Set(row["RF"].String);

                string waveId = row["WaveID"].String;
                string waveFile = JobBase.GenerateLocalFile(waveId, row["WaveBinary"].Binary, FileExtensions.Waveform, waveDir);
                string lpcFile = JobBase.GenerateLocalFile(waveId, row["LPC"].String, FileExtensions.F0File, false, lpcDir);
                string errorFile = Path.Combine(residual0Dir, waveId + "." + FileExtensions.Text);

                string[] argument = { waveFile, lpcFile, errorFile, frameShift, frameLength };
                F0ExtractorCOSMOS.ExtractLpcResidualErrorOneFile(argument, null);

                outputRow["ERR"].Set(File.ReadAllText(errorFile));
                yield return outputRow;
            }
        }

        /// <summary>
        /// Main processing script.
        /// </summary>
        /// <param name="input">The input row.</param>
        /// <param name="outputRow">The output row.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>The IEnumerable output row.</returns>
        public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
        {
            string relatedFeatureDir = "relatedFeature";
            string residualDir = "residual";
            string nccfDir = "nccf";
            string mergedDir = "merged";
            Directory.CreateDirectory(relatedFeatureDir);
            Directory.CreateDirectory(residualDir);
            Directory.CreateDirectory(nccfDir);
            Directory.CreateDirectory(mergedDir);

            foreach (var row in input.Rows)
            {
                outputRow["WaveID"].Set(row["WaveID"].String);
                outputRow["WaveBinary"].Set(row["WaveBinary"].Binary);
                outputRow["WaveAlignments"].Set(row["WaveAlignments"].String);
                outputRow["RawF0"].Set(row["RawF0"].String);
                outputRow["LPCC"].Set(row["LPCC"].Binary);
                outputRow["OF0"].Set(row["OF0"].String);
                outputRow["LSP"].Set(row["LSP"].Binary);
                outputRow["Pow"].Set(row["Pow"].String);
                outputRow["MBE"].Set(row["MBE"].String);

                string waveId = row["WaveID"].String;
                string relatedFeatureFile = JobBase.GenerateLocalFile(waveId, row["RF"].String, FileExtensions.Text, false, relatedFeatureDir);
                string residualFile = JobBase.GenerateLocalFile(waveId, row["ERR"].String, FileExtensions.Text, false, residualDir);
                string nccfFile = JobBase.GenerateLocalFile(waveId, row["NCCF"].String, FileExtensions.F0File, true, nccfDir);
                string mergedFeatureFile = Path.Combine(mergedDir, waveId + "." + FileExtensions.Text);

                string[] argument = { relatedFeatureFile, residualFile, nccfFile, mergedFeatureFile };
                F0ExtractorCOSMOS.MergeFeaturesOneFile(argument, null);

                outputRow["MERG"].Set(File.ReadAllText(mergedFeatureFile));
                yield return outputRow;
            }
        }

 /*
 ** Insert a new value into a RowSet.
 **
 ** The mallocFailed flag of the database connection is set if a
 ** memory allocation fails.
 */
 static void sqlite3RowSetInsert( RowSet p, i64 rowid )
 {
     RowSetEntry pEntry;       /* The new entry */
       RowSetEntry pLast;        /* The last prior entry */
       Debug.Assert( p != null );
       if ( p.nFresh == 0 )
       {
     RowSetChunk pNew;
     pNew = new RowSetChunk();//sqlite3DbMallocRaw(p.db, sizeof(*pNew));
     if ( pNew == null )
     {
       return;
     }
     pNew.pNextChunk = p.pChunk;
     p.pChunk = pNew;
     p.pFresh = pNew.aEntry;
     p.nFresh = ROWSET_ENTRY_PER_CHUNK;
       }
       p.pFresh[p.pFresh.Length - p.nFresh] = new RowSetEntry();
       pEntry = p.pFresh[p.pFresh.Length - p.nFresh];
       p.nFresh--;
       pEntry.v = rowid;
       pEntry.pRight = null;
       pLast = p.pLast;
       if ( pLast != null )
       {
     if ( p.isSorted && rowid <= pLast.v )
     {
       p.isSorted = false;
     }
     pLast.pRight = pEntry;
       }
       else
       {
     Debug.Assert( p.pEntry == null );/* Fires if INSERT after SMALLEST */
     p.pEntry = pEntry;
       }
       p.pLast = pEntry;
 }

 /*
 ** Turn bulk memory into a RowSet object.  N bytes of memory
 ** are available at pSpace.  The db pointer is used as a memory context
 ** for any subsequent allocations that need to occur.
 ** Return a pointer to the new RowSet object.
 **
 ** It must be the case that N is sufficient to make a Rowset.  If not
 ** an assertion fault occurs.
 **
 ** If N is larger than the minimum, use the surplus as an initial
 ** allocation of entries available to be filled.
 */
 static RowSet sqlite3RowSetInit( sqlite3 db, object pSpace, u32 N )
 {
     RowSet p = new RowSet( db, (int)N );
       //Debug.Assert(N >= ROUND8(sizeof(*p)) );
       //  p = pSpace;
       //  p.pChunk = 0;
       //  p.db = db;
       //  p.pEntry = 0;
       //  p.pLast = 0;
       //  p.pTree = 0;
       //  p.pFresh =(struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p);
       //  p.nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry));
       //  p.isSorted = 1;
       //  p.iBatch = 0;
       return p;
 }

 /*
 ** Deallocate all chunks from a RowSet.  This frees all memory that
 ** the RowSet has allocated over its lifetime.  This routine is
 ** the destructor for the RowSet.
 */
 static void sqlite3RowSetClear( RowSet p )
 {
     RowSetChunk pChunk, pNextChunk;
       for ( pChunk = p.pChunk; pChunk != null; pChunk = pNextChunk )
       {
     pNextChunk = pChunk.pNextChunk;
     sqlite3DbFree( p.db, ref pChunk );
       }
       p.pChunk = null;
       p.nFresh = 0;
       p.pEntry = null;
       p.pLast = null;
       p.pTree = null;
       p.isSorted = true;
 }