/// <summary>
        /// PerformEach() - Process an "Each" command in the line (it it exists).
        /// </summary>
        /// <param name="line">Line to process</param>
        /// <param name="outputLines">Output Lines List (to add items to)</param>
        /// <returns>Line (if "Each" is not present or "{{Ignore}}" if the "Each" was processed.</returns>
        private string PerformEach(string line, List <string> outputLines)
        {
            string workLine;
            bool   isFirst;
            bool   isLast;
            int    itemNum = 0;

            if (line.Contains("{{Each|") == false)
            {
                return(line);
            }

            CommandParser cmd = new CommandParser(line);

            cmd.Parse();

            List <ColumnData> workColList = GetWorkColumnList(cmd.Param1);

            foreach (ColumnData item in workColList)
            {
                itemNum++;
                isFirst = (itemNum == 1);
                isLast  = (itemNum == workColList.Count);

                workLine = cmd.Prefix + cmd.Param2 + cmd.Suffix;
                workLine = workLine.Replace("[[ColName]]", item.ColumnName);
                workLine = workLine.Replace("[[CamelColName]]", GetCamelCase(item.ColumnName));
                workLine = workLine.Replace("[[ColSqlType]]", item.SqlDataType);
                workLine = workLine.Replace("[[ColCodeType]]", DataTypeLookup.GetCodeDataType(item));
                workLine = workLine.Replace("[[ColCodeDefaultValue]]", DataTypeLookup.GetCodeDefaultValue(item));
                workLine = workLine.Replace("[[TableAlias]]", (TableAlias == "") ?  "" : $"{TableAlias}.");


                if (workLine.Contains("[First|"))
                {
                    ModifierParser mp = new ModifierParser(workLine, isFirst);
                    workLine = mp.Parse();
                }

                if (workLine.Contains("[Last|"))
                {
                    ModifierParser mp = new ModifierParser(workLine, isLast);
                    workLine = mp.Parse();
                }

                workLine = PerformIf(workLine);

                outputLines.Add(workLine);
            }

            return("{{Ignore}}");
        }
        /// <summary>
        /// CamelIdColParameters() - Formats and return the id columns as parameters to a
        /// method (i.e. - "{data type} {varable name}, ...")
        /// </summary>
        /// <param name="varsOnly">Only include variables? (Not data types)</param>
        /// <returns>Id columns as parameters</returns>
        private string CamelIdColParameters(bool varsOnly)
        {
            StringBuilder     sb        = new StringBuilder();
            List <ColumnData> idColList = GetWorkColumnList("IdCols");
            bool isFirstTime            = true;

            foreach (ColumnData col in idColList)
            {
                sb.Append((isFirstTime) ? "" :  ", ");
                sb.Append((varsOnly) ? "" : DataTypeLookup.GetCodeDataType(col) + " ");
                sb.Append(GetCamelCase(col.ColumnName));
                isFirstTime = false;
            }
            return(sb.ToString());
        }
        /// <summary>
        /// GetSpecialColType() - Retrieves the SQL or CodeType for s special column.
        /// </summary>
        /// <param name="specialCol">Special Column (Name or Active)</param>
        /// <param name="colType">Column Type (SQL or Code)</param>
        /// <returns>SQL or Data Type for the Name or Active column</returns>
        private string GetSpecialColType(string specialCol, string colType)
        {
            string workCol = (specialCol.ToLower() == "name") ? NameColumn : ActiveColumn;

            if (workCol == "")
            {
                return("");
            }

            ColumnData col = ColDataList.Find(cd => cd.ColumnName == workCol);

            if (col is null)
            {
                return("");
            }

            return((colType.ToLower() == "sql") ? col.SqlDataType : DataTypeLookup.GetCodeDataType(col));
        }