WebBuild/wwwroot/platform/datasources/components/queryparser/queryparser.js

var Unibase;
(function (Unibase) {
    let Platform;
    (function (Platform) {
        let DataSources;
        (function (DataSources) {
            let Components;
            (function (Components) {
                class QueryParser extends Unibase.Platform.Core.BaseComponent {
                    constructor() {
                        super(...arguments);
                        this.ErrorThrown = false;
                        this.starCount = 0;
                    }
                    getInitialSelectHtml(SubQuery, Union) {
                        Union && (SubQuery = true);
                        let sub_query_cls = this.getContainerClass(SubQuery, Union);
                        let cls = (SubQuery ? Union ? (sub_query_cls + " union_query") : (sub_query_cls + " sub_query") : "main_query");
                        return `<div class="${cls} select_container" id= "${sub_query_cls}">
                                <a class="btn remove_btn ${!SubQuery && "hidden"} pull-right" href="javascript:;"><i class="las la-times font-18"></i></a>
                                <div class='initialselect_div row'>
                                    <div class="row star_container ${sub_query_cls}">
                                        <strong>select * </strong>
                                        <div class="custom-control custom-checkbox checkbox-primary ml-10">
                                            <input type="checkbox" class="custom-control-input ${sub_query_cls} query_star" id="query_select_star_${++this.starCount}" checked="">
                                            <label class="custom-control-label" for="query_select_star_${this.starCount}"></label>
                                        </div>
                                        <div class="tables_star_container row">
                                            
                                        </div>
                                    <a href="javascript:;" class="get_tables_star"> refresh tables star's </a>
                                    <a class="btn remove_btn ${!SubQuery && "hidden"}" href="javascript:;"><i class="las la-times font-18"></i></a>
                                    </div>
                                 </div>
                                <div class="datalist_column_container ${sub_query_cls} row">
                                    ${this.getAddColumnHtml()}
                                </div>
                                <div class="datalist_tables_container ${sub_query_cls}" >
                                    ${this.getTableHtml()}
                                </div>
                                <div class="datalist_where_container row mt-40 ${sub_query_cls}">
                                    ${this.getInitialWhereHtml(sub_query_cls)}
                                </div>
                                <div class="datalist_ord_grp_hav_container row mt-40 ${sub_query_cls}">
                                   ${this.getInitialClauseHtml(sub_query_cls)}
                                </div>
                                </div>
                                   ${this.getUnionDropDwnHtml()}`;
                    }
                    getContainerClass(SubQuery, Union) {
                        let sub_query_cls = "sub_query_" + ($(".sub_query").length + 1);
                        if (!SubQuery && !Union)
                            sub_query_cls = "main_query";
                        else if (Union) {
                            Union && (SubQuery = true);
                            sub_query_cls = "union_query_" + ($(".union_query").length + 1);
                        }
                        return sub_query_cls;
                    }
                    getAddColumnHtml() {
                        return ` <div class='datalist_column row col-6'>
                                        <input type="text" class="form-control col-5 datalist_column_name" placeholder="Column Name">
                                        <strong class="">As</strong>
                                        <input type="text" class="form-control col-2 datalist_column_alias_name" placeholder="Alias Name">
                                        <button class="btn btn-icon btn-secondary add_datalist_column">
                                            <span class="btn-icon-wrap"><i class="icon-plus"></i></span></button>
                                    </div>`;
                    }
                    getTableHtml() {
                        return `<div class='datalist_tablename_container row'>
                                            <strong>from</strong>
                                            <input type="text" class="form-control col-5 table_name" placeholder="Table Name">
                                              <div class="custom-control is_subquery_chk_box_wrapper  custom-checkbox checkbox-primary ml-10">
                                                <input type="checkbox" class="custom-control-input  is_subquery" id="is_subquery_${++this.starCount}" data-ischecked=false>
                                                <label class="custom-control-label" for="is_subquery_${this.starCount}"></label>
                                             </div>
                                            <strong>As</strong>
                                            <input type="text" class="form-control col-3 alias_name" placeholder="Alias Name">
                                            <button class="btn btn-icon btn-secondary add_join">
                                            <span class="btn-icon-wrap"><i class="icon-plus"></i></span>
                                            </button>
                                            <div class="sub_query_div hidden w-100" ></div>
                                    </div>`;
                    }
                    getJoinDropDown() {
                        return `<select class="form-control custom-select join_dropdown col-1">
                                        <option value="1" selected>Inner Join</option>
                                        <option value="2">Outer Join</option>
                                        <option value="3">Left Join</option>
                                        <option value="4">Full JOin</option>
                                        <option value="5">Right Join</option>
                                        <option value="6">Cross Join</option>
                                    </select>`;
                    }
                    getJoinHtml() {
                        return `<div class="join_row row">
                                    <select class="form-control custom-select join_dropdown col-1">
                                        <option value="1" selected>Inner Join</option>
                                        <option value="2">Outer Join</option>
                                        <option value="3">Left Join</option>
                                        <option value="4">Full JOin</option>
                                        <option value="5">Right Join</option>
                                        <option value="6">Cross Join</option>
                                    </select>
                                    <input type="text" class="form-control table_name col-2" placeholder="Join table">
                                    <div class="custom-control is_subquery_chk_box_wrapper custom-checkbox checkbox-primary ml-10">
                                        <input type="checkbox" class="custom-control-input is_subquery" id="is_subquery_${++this.starCount}" data-ischecked=false >
                                        <label class="custom-control-label" for="is_subquery_${this.starCount}"></label>
                                    </div>
                                    <strong>As</strong>
                                    <input type="text" class="form-control alias_name col-1" placeholder="Alias Name">
                                    <strong>on</strong>
                                    <input type="text" class="form-control join_table1_column col-2" placeholder="Condition">
                                    <strong>=</strong>
                                    <input type="text" class="form-control join_table2_column col-2" placeholder="Condition">
                                        <button class="btn btn-icon btn-secondary add_join">
                                            <span class="btn-icon-wrap"><i class="icon-plus"></i></span>
                                            </button>
                                    <div class="sub_query_div hidden w-100" ></div>

                                </div>`;
                    }
                    getInitialWhereHtml(cls) {
                        return `<div class="div_where_container ${cls}">
                                <strong>Where </strong>
                                ${this.getWhereHtml(cls)}
                                </div>`;
                    }
                    getWhereHtml(cls) {
                        return ` <div class ='condition_row ${cls} row'>
                                <input type="text" class="form-control col-3 aggregation_column_name" placeholder="Column Name">
                                <div class="whr_btw_wrapper row col-7">
                                <select class="form-control custom-select aggregation_type_operator col-3">
                                    <option value="1" selected>Equal to</option>
                                    <option value="2">Greater Than</option>
                                    <option value="3">Less Than</option>
                                    <option value="4">Between</option>
                                    <option value="5">Greater Than Equal to</option>
                                    <option value="6">Less Than Equal to</option>
                                    <option value="7">Not Equal to</option>
                                    <option value="8">Less Than Column</option>
                                    <option value="9">Greater Than Column</option>
                                    <option value="10">In</option>
                                    <option value="11">Not In</option>
                                    <option value="12">Is Null</option>
                                    <option value="13">!Is Null</option>
                                </select>
                                <input type="text" class="form-control col-4 value1" placeholder="Enter Value">
                                ${this.getBetweenHtml()}
                                <div class="custom-control where_subquery_wrapper custom-checkbox checkbox-primary ml-10">
                                    <input type="checkbox" class="custom-control-input where_subquery" id="is_subquery_${++this.starCount}"" data-ischecked="false">
                                    <label class="custom-control-label" for="is_subquery_${this.starCount}""></label>
                                </div>
                                </div>
                                <select class="form-control custom-select add_condition col-1">
                                    <option value="0" selected>Add Conditon</option>
                                    <option value="1">And</option>
                                    <option value="2">Or</option>
                                </select>
                                <div class="sub_query_div hidden w-100" ></div>
                                 </div>`;
                    }
                    getBetweenHtml() {
                        return `<div class="btw_wrapper row hidden col-5"> <strong>And</strong>
                                <input type="text" class="form-control col-10 value2" placeholder="Enter Value">
                                </div>`;
                    }
                    getInitialClauseHtml(cls) {
                        return `<div class="clause_container ${cls} col-12" >
                                <strong>Clause</strong>
                                ${this.getClauseHtml()}
                                </div>`;
                    }
                    getClauseDwnHtml() {
                        return `<select class="form-control custom-select clause_type col-1">
                                    <option value="1">Order by</option>
                                    <option value="2">Group by</option>
                                    <option value="3">Having</option>
                                </select>`;
                    }
                    getClauseHtml() {
                        return `<div class="clause_row row">
                                ${this.getClauseDwnHtml()}
                                <div class="clause_wrapper row col-8">
                               ${this.getOrderByAggregationHtml()}
                                </div>
                                <button class="btn btn-icon btn-secondary add_clause">
                                    <span class="btn-icon-wrap"><i class="icon-plus"></i></span>
                                </button>
                                </div>`;
                    }
                    getClauseWrapperWithHavingHtml() {
                        return ` <div class="clause_wrapper row col-8">
                               ${this.getHavingClauseHtml()}
                                </div>`;
                    }
                    getOrderByAggregationHtml() {
                        return `<input type="text" class="form-control col-8 columns" placeholder="columns seperated by (,)">
                                <select class="form-control custom-select order_by_type col-2">
                                    <option value="1" selected>Asc</option>
                                    <option value="2">Desc</option>
                                </select>`;
                    }
                    getGroupByClauseHtml() {
                        return `<input type="text" class="form-control col-8 columns" placeholder="columns seperated by (,)">`;
                    }
                    getHavingClauseHtml() {
                        return `<input type="text" class="form-control col-2 column_name" placeholder="Enter Column">
                                <select class="form-control custom-select clause_expression_type col-2">
                                    <option value="1" selected>Equal to</option>
                                    <option value="2">Greater Than</option>
                                    <option value="3">Less Than</option>
                                    <option value="4">Between</option>
                                    <option value="5">Greater Than Equal to</option>
                                    <option value="6">Less Than Equal to</option>
                                    <option value="7">Not Equal to</option>
                                    <option value="8">Less Than Column</option>
                                    <option value="9">Greater Than Column</option>
                                    <option value="10">In</option>
                                    <option value="11">Not In</option>
                                    <option value="12">Is Null</option>
                                    <option value="13">!Is Null</option>
                                </select>
                                <input type="text" class="form-control col-2 value1" placeholder="Enter Value">
                                ${this.getBetweenHtml()}
                                <select class="form-control custom-select add_having_clause col-1">
                                    <option value="0" selected>Add Having</option>
                                    <option value="1">And</option>
                                    <option value="2">Or</option>
                                </select>
                                `;
                    }
                    getUnionDropDwnHtml() {
                        return `<select class="form-control custom-select union_drop_down col-1">
                                        <option value="0" selected>select</option>
                                        <option value="1"> Union </option>
                                        <option value="2"> Union All </option>
                                    </select>`;
                    }
                    mouseDown(e) {
                        let container = $(e.target).closest(".select_container");
                        let container_cls = container.attr("id");
                        if (e.target.closest(".add_datalist_column") || e.target.classList.contains("add_datalist_column")) {
                            container.find(`.${container_cls}.datalist_column_container`).first().children().last().find('.add_datalist_column').addClass("hidden");
                            container.find(`.${container_cls}.datalist_column_container`).first().children().last().append(this.getCloseBtnHtml());
                            container.find(`.${container_cls}.datalist_column_container`).first().append(this.getAddColumnHtml());
                        }
                        else if (e.target.closest(".remove_btn") || e.target.classList.contains("remove_btn")) {
                            let datalistColumnRow = $(e.target).closest(".datalist_column");
                            let joinRow = $(e.target).closest(".join_row");
                            let conditionRow = $(e.target).closest(".condition_row");
                            let clauseRow = $(e.target).closest(".clause_row");
                            let initialSelect = $(e.target).closest(".initialselect_div").first();
                            let subquery = $(e.target).closest(".sub_query").first();
                            let subQueryDiv = $(e.target).closest(".sub_query_div").first();
                            if (datalistColumnRow.length)
                                datalistColumnRow.remove();
                            else if (clauseRow.length)
                                clauseRow.remove();
                            else if (joinRow.length)
                                joinRow.remove();
                            else if (conditionRow.length)
                                conditionRow.remove();
                            else if (initialSelect.length) {
                                initialSelect.parent().next().remove();
                                initialSelect.parent().prev().val("0");
                                initialSelect.parent().remove();
                                if (!subQueryDiv.children().length) {
                                    subQueryDiv.addClass("hidden");
                                }
                            }
                            else if (subquery.length && !datalistColumnRow.length && !clauseRow.length && !joinRow.length && !conditionRow.length && !initialSelect.length) {
                                subQueryDiv.empty().addClass("hidden");
                            }
                        }
                        else if (e.target.closest(".add_join") || e.target.classList.contains("add_join")) {
                            $(e.target).closest(".join_row").append(this.getCloseBtnHtml());
                            $(e.target).closest(".add_join").remove();
                            container.find(`.${container_cls}.datalist_tables_container`).first().append(this.getJoinHtml());
                        }
                        else if (e.target.closest(".add_clause") || e.target.classList.contains("add_clause")) {
                            $(e.target).closest(".clause_row").append(this.getCloseBtnHtml());
                            container.find(`.${container_cls}.clause_container`).first().append(this.getClauseHtml());
                            $(e.target).closest(".add_clause").remove();
                        }
                        else if (e.target.classList.contains("get_tables_star")) {
                            let element;
                            let clst_sub_query = $(e.target).closest(".sub_query");
                            let clst_main_query = $(e.target).closest("#main_query");
                            let clst_union_query = $(e.target).closest(".union_query");
                            if (clst_union_query.length) {
                                element = clst_union_query;
                            }
                            else if (clst_sub_query.length) {
                                element = clst_sub_query;
                            }
                            else if (clst_main_query.length) {
                                element = clst_main_query;
                            }
                            $(e.target).prev().html(this.getStarHtml(element));
                        }
                        else if (e.target.closest(".is_subquery_chk_box_wrapper") || e.target.classList.contains("is_subquery")) {
                            let checkbox = $(e.target).siblings(".is_subquery").length ? $(e.target).siblings(".is_subquery") : $(e.target).closest(".is_subquery");
                            let checkbox_wrapper = $(e.target).closest(".is_subquery_chk_box_wrapper");
                            let is_subquery = !checkbox.data("ischecked");
                            let sub_query_div = checkbox_wrapper.siblings(".sub_query_div");
                            checkbox.data("ischecked", is_subquery);
                            if (is_subquery) {
                                sub_query_div.removeClass("hidden");
                                if (!sub_query_div.children().length)
                                    sub_query_div.append(this.getInitialSelectHtml(true));
                            }
                            else {
                                sub_query_div.addClass("hidden");
                            }
                        }
                        else if (e.target.closest(".where_subquery_wrapper") || e.target.classList.contains("where_subquery")) {
                            let checkbox = $(e.target).siblings(".where_subquery").length ? $(e.target).siblings(".where_subquery") : $(e.target).closest(".where_subquery");
                            let checkbox_wrapper = $(e.target).closest(".where_subquery_wrapper");
                            let is_subquery = !checkbox.data("ischecked");
                            let sub_query_div = checkbox_wrapper.parent().siblings(".sub_query_div");
                            checkbox.data("ischecked", is_subquery);
                            if (is_subquery) {
                                sub_query_div.removeClass("hidden");
                                checkbox.prop("checked", true);
                                if (!sub_query_div.children().length)
                                    sub_query_div.append(this.getInitialSelectHtml(true));
                            }
                            else {
                                sub_query_div.addClass("hidden");
                                checkbox.prop("checked", false);
                            }
                        }
                    }
                    changeEvent(e) {
                        let container = $(e.target).closest(".select_container");
                        let cls = container.attr("id");
                        if (e.target.closest(".aggregation_type_operator") || e.target.classList.contains("aggregation_type_operator")) {
                            if (e.target.selectedIndex + 1 == DataSources.Enums.ExpressionType.Between) {
                                $(e.target.closest(".whr_btw_wrapper")).find(".btw_wrapper").removeClass("hidden");
                            }
                            else {
                                $(e.target.closest(".whr_btw_wrapper")).find(".btw_wrapper").addClass("hidden");
                            }
                            if (e.target.selectedIndex + 1 == DataSources.Enums.ExpressionType.IsNull || e.target.selectedIndex + 1 == DataSources.Enums.ExpressionType.IsNotNull) {
                                $(e.target).next().addClass("hidden");
                            }
                            else {
                                $(e.target).next().removeClass("hidden");
                            }
                        }
                        else if (e.target.closest(".clause_expression_type") || e.target.classList.contains("clause_expression_type")) {
                            if (e.target.selectedIndex + 1 == DataSources.Enums.ExpressionType.Between) {
                                $(e.target.closest(".clause_wrapper")).find(".btw_wrapper").removeClass("hidden");
                            }
                            else {
                                $(e.target.closest(".clause_wrapper")).find(".btw_wrapper").addClass("hidden");
                            }
                            if (e.target.selectedIndex + 1 == DataSources.Enums.ExpressionType.IsNull || e.target.selectedIndex + 1 == DataSources.Enums.ExpressionType.IsNotNull) {
                                $(e.target).next().addClass("hidden");
                            }
                            else {
                                $(e.target).next().removeClass("hidden");
                            }
                        }
                        else if (e.target.closest(".clause_type") || e.target.classList.contains("clause_type")) {
                            if (Number(e.target.value) == Unibase.Platform.DataSources.Enums.ClauseType.OrderBy) {
                                $(e.target).closest(".clause_row").find(".clause_wrapper").html(this.getOrderByAggregationHtml());
                            }
                            else if (Number(e.target.value) == Unibase.Platform.DataSources.Enums.ClauseType.GroupBy) {
                                $(e.target).closest(".clause_row").find(".clause_wrapper").html(this.getGroupByClauseHtml());
                            }
                            else if (Number(e.target.value) == Unibase.Platform.DataSources.Enums.ClauseType.Having) {
                                $(e.target).closest(".clause_row").find(".clause_wrapper").html(this.getHavingClauseHtml());
                            }
                        }
                        else if (e.target.closest(".add_condition") || e.target.classList.contains("add_condition")) {
                            let conditionRow = $(e.target).closest(".condition_row");
                            if (!conditionRow.next(".condition_row").length) {
                                conditionRow.append(this.getCloseBtnHtml());
                                conditionRow.after(this.getWhereHtml(cls));
                            }
                        }
                        else if (e.target.closest(".add_having_clause") || e.target.classList.contains("add_having_clause")) {
                            let currentClauseWrapper = $(e.target).closest(".clause_wrapper");
                            if (Number(e.target.value) != 0 && !currentClauseWrapper.next(".clause_wrapper").length) {
                                currentClauseWrapper.after(this.getClauseWrapperWithHavingHtml());
                            }
                        }
                        else if (e.target.classList.contains("union_drop_down")) {
                            if (Number(e.target.value) != 0 && !$(e.target).next(".select_container").length) {
                                $(e.target).parent().append(this.getInitialSelectHtml(false, true));
                            }
                        }
                    }
                    getIsSubOrUnionFromCls(cls) {
                        let IsSub;
                        let IsUni;
                        let IsMain;
                        if (cls) {
                            if (cls.startsWith("main_"))
                                IsMain = false;
                            else if (cls.startsWith("sub_"))
                                IsSub = true;
                            else if (cls.startsWith("union_"))
                                IsUni = true;
                        }
                        return { IsSubQuery: IsSub, IsUnionQuery: IsUni, IsMainQuery: IsMain };
                    }
                    getOperatorSymbolFromText(text) {
                        let returnString = "";
                        switch (text) {
                            case "greater than":
                                returnString = ">";
                                break;
                            case "less than":
                                returnString = "<";
                                break;
                            case "equal to":
                                returnString = "=";
                                break;
                            case "greater than equal to":
                                returnString = ">=";
                                break;
                            case "less than equal to":
                                returnString = "<=";
                                break;
                            case "not equal to":
                                returnString = "!=";
                                break;
                        }
                        return returnString ? returnString : text;
                    }
                    showError(message) {
                        this.ErrorThrown = true;
                        return MessageHelper.Instance().showError(message, 'bl-datalist_error');
                    }
                    getCloseBtnHtml() {
                        return `<a class="btn remove_btn" href="javascript:;"><i class="las la-times font-18"></i></a>`;
                    }
                    getStarHtml(SelectContainerJqueryEle) {
                        let dataListTables = [];
                        let container_cls = SelectContainerJqueryEle.attr("id");
                        let tablesContainer = SelectContainerJqueryEle.find(".datalist_tables_container").first().children();
                        let html = "";
                        let isGlobalStartSelected;
                        isGlobalStartSelected = SelectContainerJqueryEle.find("." + container_cls + ".query_star").first().prop("checked");
                        jQuery.each(tablesContainer, (index, column) => {
                            let tableName = $(column).find(".table_name").val();
                            let aliasName = $(column).find(".alias_name").val();
                            if (!tableName && !aliasName)
                                return;
                            let table = {
                                DocTableAliasName: aliasName ? aliasName : tableName,
                                DocTypeTableName: tableName,
                                IsMainTable: index == 0 ? true : false,
                                IsSubQuery: false,
                                IsStarSelected: index == 0 ? isGlobalStartSelected : false,
                            };
                            dataListTables.push(table);
                        });
                        for (var i = 0; i < dataListTables.length; i++) {
                            html += `<div class="select_star_wrapper"><strong>${dataListTables[i].DocTableAliasName}</strong>
                                        <div class="custom-control custom-checkbox checkbox-primary ml-10">
                                            <input type="checkbox" class="custom-control-input table_star" id="${(dataListTables[i].DocTableAliasName + "_select_star")}" >
                                            <label class="custom-control-label" for="${(dataListTables[i].DocTableAliasName + "_select_star")}"></label>
                                        </div></div>`;
                        }
                        return html;
                    }
                    generateDynamicQuery(SelectContainerEle) {
                        let dataListColumns = [];
                        let dataListJoins = [];
                        let dataListTables = [];
                        let dataListWhere = [];
                        let dataListClause = [];
                        let dynamicQuery;
                        let select_cls = SelectContainerEle.attr("id");
                        let unionType = parseInt(SelectContainerEle.next().val());
                        let unionQuery;
                        let isGlobalStartSelected = SelectContainerEle.find("." + select_cls + ".query_star").first().prop("checked");
                        let columnsContainer = SelectContainerEle.find("." + select_cls + ".datalist_column_container").first().children();
                        let tablesContainer = SelectContainerEle.find("." + select_cls + ".datalist_tables_container").first().children();
                        let whereContainer = SelectContainerEle.find("." + select_cls + ".datalist_where_container").first().find("." + select_cls + ".condition_row");
                        let clauseContainer = SelectContainerEle.find("." + select_cls + ".clause_container").first().children(".clause_row");
                        jQuery.each(columnsContainer, (index, column) => {
                            let aliasName = $(column).find(".datalist_column_alias_name").val();
                            let columnName = $(column).find(".datalist_column_name").val();
                            if (index == 0 && !aliasName && !columnName)
                                return;
                            let newColumn = {
                                ColumnName: columnName,
                                AliasName: aliasName ? aliasName : columnName,
                            };
                            if (!columnName)
                                return;
                            dataListColumns.push(newColumn);
                        });
                        jQuery.each(tablesContainer, (index, column) => {
                            let dynamicSubQuery;
                            let joinType = $(column).find(".join_dropdown").val();
                            let tableName = $(column).find(".table_name").val();
                            let aliasName = $(column).find(".alias_name").val();
                            let table1_clmn = $(column).find(".join_table1_column").val();
                            let table2_clmn = $(column).find(".join_table2_column").val();
                            let is_subquery = $(column).find(".is_subquery").first().data("ischecked");
                            let is_star_selected = false;
                            if (is_subquery) {
                                let subQuerySelectContainer = $(column).children(".is_subquery_chk_box_wrapper").siblings(".sub_query_div").find(".select_container").first();
                                dynamicSubQuery = this.generateDynamicQuery(subQuerySelectContainer);
                            }
                            let JoinTable = {
                                DocTypeTable1Column: table1_clmn,
                                DocTypeTable2Column: table2_clmn
                            };
                            let table = {
                                DocTableAliasName: aliasName ? aliasName : tableName,
                                DocTypeTableName: tableName,
                                IsMainTable: index == 0 ? true : false,
                                IsSubQuery: is_subquery,
                                IsStarSelected: is_star_selected,
                                SubQuery: dynamicSubQuery,
                            };
                            table.IsStarSelected = SelectContainerEle.find("#" + table.DocTableAliasName + "_select_star").is(":checked");
                            let join = {
                                DocTypeTableName: tableName,
                                DocTableAliasName: aliasName,
                                IsPrimaryKey: false,
                                on: JoinTable,
                                DocJoinType: Number(joinType) || 0,
                            };
                            if (!table.DocTypeTableName)
                                return;
                            dataListTables.push(table);
                            dataListJoins.push(join);
                        });
                        jQuery.each(whereContainer, (index, column) => {
                            let columnName = $(column).find(".aggregation_column_name").val();
                            let value1 = $(column).find(".value1").val();
                            let value2 = $(column).find(".value2").val();
                            let aggregation_type = $(column).find(".aggregation_type_operator option:selected").val();
                            let add_condition = $(column).find(".add_condition option:selected").val();
                            let isBetween = false;
                            let isSubQuery = $(column).find(".where_subquery").data("ischecked");
                            let subQuery;
                            Number(aggregation_type) == DataSources.Enums.ExpressionType.Between ? isBetween = true : isBetween = false;
                            if (isSubQuery) {
                                let container_ele = $(column).find(".sub_query_div .select_container").first();
                                subQuery = this.generateDynamicQuery(container_ele);
                            }
                            let where = {
                                ColumnName: columnName,
                                Value1: value1,
                                Value2: value2,
                                ExpressionType: Number(aggregation_type),
                                IsBetween: isBetween,
                                AddConditionType: Number(add_condition),
                                IsSubQuery: isSubQuery,
                                SubQuery: isSubQuery ? subQuery : null,
                            };
                            if (!where.ColumnName)
                                return;
                            dataListWhere.push(where);
                        });
                        jQuery.each(clauseContainer, (index, column) => {
                            let clauseWrappers = $(column).children(".clause_wrapper");
                            let columns = $(column).find(".columns").val();
                            let clauseType = $(column).find(".clause_type").val();
                            let orderByType = $(column).find(".order_by_type").val();
                            let value1 = $(column).find(".value1").val();
                            let value2 = $(column).find(".value2").val();
                            let exp_type = $(column).find(".clause_expression_type option:selected").val();
                            let add_condition = $(column).find(".add_having_clause option:selected").val();
                            let isHaving = false;
                            let isBetween = false;
                            Number(clauseType) == DataSources.Enums.ClauseType.Having ? isHaving = true : isHaving = false;
                            Number(exp_type) == DataSources.Enums.ExpressionType.Between ? isBetween = true : isBetween = false;
                            let havingClauseArray = [];
                            if (Number(clauseType) == DataSources.Enums.ClauseType.Having) {
                                $.each(clauseWrappers, (i, ele) => {
                                    let column = $(ele).find(".column_name").val();
                                    let value1 = $(ele).find(".value1").val();
                                    let value2 = $(ele).find(".value2").val();
                                    let exp_type = $(ele).find(".clause_expression_type option:selected").val();
                                    let add_condition = $(ele).find(".add_having_clause option:selected").val();
                                    Number(exp_type) == DataSources.Enums.ExpressionType.Between ? isBetween = true : isBetween = false;
                                    let havingClause;
                                    havingClause = {
                                        IsBetween: isBetween,
                                        Value1: value1,
                                        Value2: value2,
                                        ColumnName: column,
                                        AddConditionType: Number(add_condition),
                                        ExpressionType: Number(exp_type),
                                        IsSubQuery: false,
                                        SubQuery: null
                                    };
                                    havingClauseArray.push(havingClause);
                                });
                            }
                            let clause = {
                                ClauseType: Number(clauseType),
                                Columns: columns,
                                IsHaving: isHaving,
                                OrderBy: Number(orderByType) || 0,
                                Having: havingClauseArray,
                            };
                            if ((!clause.IsHaving && !clause.Columns) || (clause.IsHaving && clause.Having.length && !clause.Having[0].ColumnName))
                                return;
                            dataListClause.push(clause);
                        });
                        if (!isGlobalStartSelected && !dataListColumns.length)
                            return new DataSources.Requests.DynamicQuery();
                        if (this.ErrorThrown)
                            return;
                        dynamicQuery = {
                            DataListColumns: dataListColumns,
                            DataListDocTypes: dataListTables,
                            DataListWhere: dataListWhere,
                            DataListJoins: dataListJoins,
                            DataListClause: dataListClause,
                            IsStarSelected: isGlobalStartSelected,
                            IsUnion: false,
                            UnionType: 1,
                            UnionQuery: null,
                            TempName: null,
                        };
                        if (unionType) {
                            let unionElement = SelectContainerEle.next().next();
                            unionQuery = this.generateDynamicQuery(unionElement);
                            dynamicQuery.IsUnion = true;
                            dynamicQuery.UnionType = unionType;
                            dynamicQuery.UnionQuery = unionQuery;
                        }
                        return dynamicQuery;
                    }
                    bindDynamicQuery(dynamic, SubQuery, IsUnion) {
                        let queryCls = SubQuery ? ("sub_query_" + ($(".sub_query").length)) : "main_query";
                        if (IsUnion)
                            queryCls = "union_query_" + ($(".union_query").length);
                        var columnsContainer = $(`.${queryCls}.datalist_column_container`).children();
                        var tablesContainer = $(`.${queryCls}.datalist_tables_container`).children();
                        var whereContainer = $(`.${queryCls}.datalist_where_container`).find(`.${queryCls}.condition_row`);
                        var clauseContainer = $(`.${queryCls}.clause_container`).children(`.clause_row`);
                        for (var i = 0; i < dynamic.DataListColumns.length; i++) {
                            $(columnsContainer[i]).find(".datalist_column_name").val(dynamic.DataListColumns[i].ColumnName);
                            if ((dynamic.DataListColumns[i].AliasName != dynamic.DataListColumns[i].ColumnName))
                                $(columnsContainer[i]).find(".datalist_column_alias_name").val(dynamic.DataListColumns[i].AliasName);
                            if (i != dynamic.DataListColumns.length - 1) {
                                $(columnsContainer[i]).find(".add_datalist_column").click().trigger("mousedown");
                                columnsContainer = $(`.${queryCls}.datalist_column_container`).children();
                            }
                        }
                        for (var i = 0; i < dynamic.DataListJoins.length; i++) {
                            $(tablesContainer[i]).find(".table_name").val(dynamic.DataListJoins[i].DocTypeTableName);
                            if ((dynamic.DataListJoins[i].DocTableAliasName != dynamic.DataListJoins[i].DocTypeTableName))
                                $(tablesContainer[i]).find(".alias_name").val(dynamic.DataListJoins[i].DocTableAliasName);
                            if (i != 0) {
                                $(tablesContainer[i]).find(".join_table1_column").val(dynamic.DataListJoins[i].on.DocTypeTable1Column);
                                $(tablesContainer[i]).find(".join_table2_column").val(dynamic.DataListJoins[i].on.DocTypeTable2Column);
                                $(tablesContainer[i]).find(".join_dropdown").val(dynamic.DataListJoins[i].DocJoinType.toString());
                            }
                            let table = dynamic.DataListDocTypes.find(x => x.DocTypeTableName == dynamic.DataListJoins[i].DocTypeTableName);
                            if (table && table.IsSubQuery) {
                                $(tablesContainer[i]).find(".is_subquery").click().trigger("mousedown");
                                this.bindDynamicQuery(table.SubQuery, true);
                            }
                            if (i != dynamic.DataListJoins.length - 1) {
                                $(tablesContainer[i]).find(".add_join").first().click().trigger("mousedown");
                                tablesContainer = $(`.${queryCls}.datalist_tables_container`).children();
                            }
                        }
                        for (var i = 0; i < dynamic.DataListWhere.length; i++) {
                            $(whereContainer[i]).find(".aggregation_type_operator").val(dynamic.DataListWhere[i].ExpressionType.toString()).trigger("change");
                            $(whereContainer[i]).find(".aggregation_column_name").val(dynamic.DataListWhere[i].ColumnName);
                            $(whereContainer[i]).find(".value1").val(dynamic.DataListWhere[i].Value1);
                            if (dynamic.DataListWhere[i].IsBetween) {
                                $(whereContainer[i]).find(".value2").val(dynamic.DataListWhere[i].Value2);
                            }
                            if (i != dynamic.DataListWhere.length - 1) {
                                $(whereContainer[i]).find(".add_condition").first().val(dynamic.DataListWhere[i].AddConditionType.toString()).trigger("change");
                                whereContainer = $(`.${queryCls}.datalist_where_container`).find(`.${queryCls}.condition_row`);
                            }
                            if (dynamic.DataListWhere[i].IsSubQuery) {
                                $(whereContainer[i]).find(".where_subquery").first().click().trigger("mousedown");
                                this.bindDynamicQuery(dynamic.DataListWhere[i].SubQuery, true);
                            }
                        }
                        for (var i = 0; i < dynamic.DataListClause.length; i++) {
                            $(clauseContainer[i]).find(".clause_type").val(dynamic.DataListClause[i].ClauseType.toString()).trigger("change");
                            $(clauseContainer[i]).find(".columns").val(dynamic.DataListClause[i].Columns);
                            if (dynamic.DataListClause[i].ClauseType == DataSources.Enums.ClauseType.OrderBy) {
                                $(clauseContainer[i]).find(".order_by_type").val(dynamic.DataListClause[i].OrderBy.toString());
                            }
                            else if (dynamic.DataListClause[i].ClauseType == DataSources.Enums.ClauseType.Having) {
                                let clauseWrapper = $(clauseContainer[i]).find(".clause_wrapper");
                                let havings = dynamic.DataListClause[i].Having;
                                for (var j = 0; j < havings.length; j++) {
                                    $(clauseWrapper[j]).find(".column_name").val(havings[j].ColumnName);
                                    $(clauseWrapper[j]).find(".clause_expression_type").val(havings[j].ExpressionType.toString()).trigger("change");
                                    $(clauseWrapper[j]).find(".value1").val(havings[j].Value1);
                                    if (havings[j].IsBetween)
                                        $(clauseWrapper[j]).find(".value2").val(havings[j].Value2);
                                    if (i != havings.length - 1) {
                                        $(clauseWrapper[j]).find(".add_having_clause").val(havings[j].AddConditionType.toString()).trigger("change");
                                        clauseWrapper = $(clauseContainer[i]).find(".clause_wrapper");
                                    }
                                }
                            }
                            if (i != dynamic.DataListClause.length - 1) {
                                $(clauseContainer[i]).find(".add_clause").click().trigger("mousedown");
                                clauseContainer = $(`.${queryCls}.clause_container`).children(`.clause_row`);
                            }
                        }
                        $(`.${queryCls} .get_tables_star`).first().click().trigger("mousedown");
                        for (var i = 0; i < dynamic.DataListDocTypes.length; i++) {
                            if (dynamic.DataListDocTypes[i].IsStarSelected) {
                                let radioClassName = dynamic.DataListDocTypes[i].DocTableAliasName ? dynamic.DataListDocTypes[i].DocTableAliasName : dynamic.DataListDocTypes[i].DocTypeTableName;
                                $(`#${radioClassName}_select_star`).prop("checked", true);
                            }
                        }
                        if (dynamic.IsStarSelected)
                            $("." + queryCls + ".query_star").first().prop("checked", true);
                        else
                            $("." + queryCls + ".query_star").first().prop("checked", false);
                        if (dynamic.IsUnion) {
                            $("#" + queryCls).next().val(dynamic.UnionType).trigger("change");
                            this.bindDynamicQuery(dynamic.UnionQuery, false, true);
                        }
                    }
                    parseQueryToDynamic(query) {
                        let tempQuery = query;
                        let tables = new Array();
                        let tempTables = new Array();
                        let columns = new Array();
                        let joinsArr = new Array();
                        let clauseArr = new Array();
                        let whereArr = new Array();
                        let dynamicQuery = new DataSources.Requests.DynamicQuery();
                        let sub_dynamicQuery = new DataSources.Requests.DynamicQuery();
                        let unionQuery = new DataSources.Requests.DynamicQuery();
                        let dynamicQueryArr = new Array();
                        tempQuery = tempQuery.toLowerCase().trim();
                        let selectStr = "select ";
                        let whereStr = "where ";
                        let openBrac = "(";
                        let indexOfSelect = tempQuery.indexOf(selectStr);
                        let indexOfFrom = tempQuery.indexOf("from ");
                        let indexOfBrac;
                        let remainingQuery = "";
                        let slctToFrom = "";
                        let fromToSubQuery = "";
                        let unionIdx;
                        let unionAllIdx;
                        let unionMinIdx;
                        let whereIdx;
                        let tableNames = [];
                        slctToFrom = tempQuery.substring(indexOfSelect, indexOfFrom + 5);
                        if (slctToFrom.includes(" *")) {
                            dynamicQuery.IsStarSelected = true;
                            slctToFrom = slctToFrom.replace("*", "");
                            tempQuery = tempQuery.replace("*", "").trim();
                        }
                        columns = this.getDataListColumnsFromSelectString(slctToFrom);
                        tempQuery = tempQuery.replace(slctToFrom, "").trim();
                        indexOfSelect = tempQuery.indexOf(selectStr);
                        indexOfBrac = tempQuery.indexOf(openBrac);
                        fromToSubQuery = tempQuery.substring(0, indexOfSelect - 1).trim();
                        remainingQuery = tempQuery;
                        whereIdx = tempQuery.indexOf(whereStr);
                        unionIdx = tempQuery.indexOf(" union") == -1 ? Infinity : tempQuery.indexOf(" union");
                        unionAllIdx = tempQuery.indexOf(" union all") == -1 ? Infinity : tempQuery.indexOf(" union all");
                        unionMinIdx = Math.min(unionIdx, unionAllIdx);
                        if (indexOfBrac != -1 && indexOfSelect != -1) {
                            if (indexOfBrac < indexOfSelect) {
                                while (indexOfSelect != -1) {
                                    unionIdx = remainingQuery.indexOf(" union") == -1 ? Infinity : remainingQuery.indexOf(" union");
                                    unionAllIdx = remainingQuery.indexOf(" union all") == -1 ? Infinity : remainingQuery.indexOf(" union all");
                                    indexOfSelect = remainingQuery.indexOf(selectStr);
                                    indexOfBrac = remainingQuery.indexOf(openBrac);
                                    unionMinIdx = Math.min(unionIdx, unionAllIdx);
                                    if (whereIdx > indexOfSelect && unionMinIdx > indexOfSelect) {
                                        let table = new DataSources.Requests.DataListTable();
                                        fromToSubQuery = remainingQuery.substring(0, indexOfSelect);
                                        remainingQuery = tempQuery.replace(fromToSubQuery, "").trim();
                                        fromToSubQuery = fromToSubQuery.substring(0, fromToSubQuery.lastIndexOf(openBrac)).trim();
                                        let sub_rmng_result = this.getSubQueryAndRmngQuery(remainingQuery);
                                        table.SubQuery = sub_rmng_result.SubDynamicQuery;
                                        table.DocTableAliasName = sub_rmng_result.SubQueryAliasName;
                                        table.DocTypeTableName = `__subquerytable_${++this.subQueryNumber}`;
                                        table.IsSubQuery = true;
                                        tables.push(table);
                                        remainingQuery = fromToSubQuery.trim() + ` __subquerytable_${this.subQueryNumber} ` + sub_rmng_result.RemainingQuery;
                                    }
                                    else if (whereIdx < indexOfSelect && unionMinIdx > indexOfSelect && unionMinIdx != Infinity) {
                                        let whereResult = this.getSubQueriesInWhere(remainingQuery);
                                        remainingQuery = whereResult.RemaingQuery;
                                        whereArr = whereArr.concat(whereResult.listOfWhere);
                                    }
                                    else if (indexOfSelect > unionMinIdx && unionMinIdx != Infinity && indexOfSelect != -1) {
                                        let unionResult = this.getUnionsAndRemainingQuery(remainingQuery);
                                        dynamicQuery.IsUnion = unionResult.IsUnion;
                                        dynamicQuery.UnionType = unionResult.UnionType;
                                        dynamicQuery.UnionQuery = unionResult.UnionQuery;
                                        remainingQuery = unionResult.CurrentRmngQuery;
                                    }
                                    indexOfSelect = remainingQuery.indexOf(selectStr);
                                    whereIdx = remainingQuery.indexOf(whereStr);
                                    (whereIdx == -1) && (whereIdx = Infinity);
                                    if (indexOfSelect != -1) {
                                        fromToSubQuery = remainingQuery.substring(0, indexOfSelect).trim();
                                        tempQuery = remainingQuery.replace(fromToSubQuery, "").trim();
                                    }
                                }
                                if (remainingQuery.length) {
                                    let result = this.getTablesJoinsClauses(remainingQuery);
                                    whereArr = whereArr.concat(result.Where);
                                    joinsArr = joinsArr.concat(result.Joins);
                                    clauseArr = clauseArr.concat(result.Clause);
                                    tables = tables.concat(result.Tables);
                                }
                            }
                            else if (indexOfBrac < indexOfSelect) {
                            }
                        }
                        else if (indexOfSelect != -1 && unionMinIdx != -1 && indexOfSelect > unionMinIdx) {
                            let unionResult = this.getUnionsAndRemainingQuery(tempQuery);
                            dynamicQuery.IsUnion = unionResult.IsUnion;
                            dynamicQuery.UnionType = unionResult.UnionType;
                            dynamicQuery.UnionQuery = unionResult.UnionQuery;
                            remainingQuery = unionResult.CurrentRmngQuery;
                            let result = this.getTablesJoinsClauses(remainingQuery);
                            whereArr = whereArr.concat(result.Where);
                            joinsArr = joinsArr.concat(result.Joins);
                            clauseArr = clauseArr.concat(result.Clause);
                            tables = tables.concat(result.Tables);
                        }
                        else if (indexOfSelect == -1) {
                            let result = this.getTablesJoinsClauses(tempQuery);
                            whereArr = whereArr.concat(result.Where);
                            joinsArr = joinsArr.concat(result.Joins);
                            clauseArr = clauseArr.concat(result.Clause);
                            tables = tables.concat(result.Tables);
                        }
                        dynamicQuery.DataListDocTypes = tables;
                        dynamicQuery.DataListWhere = whereArr;
                        dynamicQuery.DataListColumns = columns;
                        dynamicQuery.DataListJoins = joinsArr;
                        dynamicQuery.DataListClause = clauseArr;
                        dynamicQuery.TempName = "";
                        dynamicQuery.DataListJoins.forEach((x) => {
                            if (x.DocTypeTableName.startsWith("__")) {
                                if (x)
                                    tableNames.push(x.DocTypeTableName);
                            }
                        });
                        tempTables = Object.assign([], dynamicQuery.DataListDocTypes);
                        dynamicQuery.DataListDocTypes.filter((x) => {
                            for (var i = 0; i < tableNames.length; i++) {
                                if (tableNames[i] == x.DocTypeTableName && !x.IsSubQuery) {
                                    var idx = tempTables.indexOf(x);
                                    if (x && idx != -1)
                                        tempTables.splice(idx, 1);
                                }
                            }
                        });
                        dynamicQuery.DataListDocTypes = tempTables;
                        for (var i = 0; i < dynamicQuery.DataListDocTypes.length; i++) {
                            if (slctToFrom.includes(dynamicQuery.DataListDocTypes[i].DocTypeTableName + ".*") || slctToFrom.includes(dynamicQuery.DataListDocTypes[i].DocTableAliasName + ".*"))
                                dynamicQuery.DataListDocTypes[i].IsStarSelected = true;
                        }
                        return dynamicQuery;
                    }
                    getSubQueryAndRmngQuery(tempQuery) {
                        let selectString = "select ";
                        let fromString = "from ";
                        let openBrac = "(";
                        let closingIndex;
                        let subQuery = "";
                        let remainingQuery = "";
                        let fromToSubQuery = "";
                        let subQueryAliasName = "";
                        let whereIdx;
                        let groubyIdx;
                        let orderbyIdx;
                        let havingIdx;
                        let unionIdx;
                        let unionAllIdx;
                        let minIdx;
                        let indexOfSelect = tempQuery.indexOf(selectString);
                        let indexOfFrom = tempQuery.indexOf(fromString);
                        let sub_dynamicQuery = new DataSources.Requests.DynamicQuery();
                        closingIndex = this.getIndexOfCorrespondingCloseBracket(tempQuery);
                        subQuery = tempQuery.substring(0, closingIndex - 1);
                        remainingQuery = tempQuery.substring(closingIndex, tempQuery.length).trim();
                        whereIdx = remainingQuery.indexOf(" where") == -1 ? Infinity : remainingQuery.indexOf(" where");
                        groubyIdx = remainingQuery.indexOf(" group by") == -1 ? Infinity : remainingQuery.indexOf(" group by");
                        orderbyIdx = remainingQuery.indexOf(" order by") == -1 ? Infinity : remainingQuery.indexOf(" order by");
                        havingIdx = remainingQuery.indexOf(" having") == -1 ? Infinity : remainingQuery.indexOf(" having");
                        unionIdx = remainingQuery.indexOf(" union") == -1 ? Infinity : remainingQuery.indexOf(" union");
                        unionAllIdx = remainingQuery.indexOf(" union all") == -1 ? Infinity : remainingQuery.indexOf(" union all");
                        minIdx = Math.min(whereIdx, groubyIdx, orderbyIdx, havingIdx, unionIdx, unionAllIdx);
                        if (minIdx != Infinity) {
                            let rmngSpltedQuery = remainingQuery.split(" ");
                            let joinsArray = [];
                            let lastRelation = "";
                            let keywords = Object.values(DataSources.Enums.RelationType).filter(x => typeof (x) == "string");
                            keywords = keywords.concat(Object.values(DataSources.Enums.UnionType).filter(x => typeof (x) == "string"));
                            lastRelation = keywords.pop();
                            joinsArray = remainingQuery.split(lastRelation.toLowerCase()).map(x => x.trim());
                            for (var i = 0; i < keywords.length; i++) {
                                for (var j = 0; j < joinsArray.length; j++) {
                                    let split = joinsArray[j].split(keywords[i].toLowerCase()).map(x => x.trim());
                                    if (split.length > 1) {
                                        joinsArray.splice(j, 1);
                                        for (var k = 0; k < split.length; k++) {
                                            joinsArray.splice(j + k, 0, split[k]);
                                        }
                                    }
                                }
                            }
                            if (rmngSpltedQuery[1] && rmngSpltedQuery[1].toLowerCase() == "on") {
                                subQueryAliasName = rmngSpltedQuery[0];
                            }
                            else if (joinsArray[0].split(" ").length == 1)
                                subQueryAliasName = joinsArray[0];
                            else
                                subQueryAliasName = remainingQuery.substring(0, minIdx).trim();
                        }
                        else if (remainingQuery.length) {
                            let andIdx = remainingQuery.indexOf("and ") == -1 ? Infinity : remainingQuery.indexOf("and ");
                            let orIdx = remainingQuery.indexOf("or ") == -1 ? Infinity : remainingQuery.indexOf("or ");
                            minIdx = Math.min(orIdx, andIdx);
                            if (minIdx != Infinity && minIdx != 0) {
                                subQueryAliasName = remainingQuery.substring(0, minIdx);
                            }
                            else if (remainingQuery.split(" ")[0].trim() == "as") {
                                subQueryAliasName = remainingQuery.split(" ")[1];
                            }
                            else if (minIdx != 0)
                                subQueryAliasName = remainingQuery;
                        }
                        if (fromToSubQuery.length > 1 && fromToSubQuery != openBrac)
                            remainingQuery = fromToSubQuery + remainingQuery;
                        indexOfSelect = subQuery.indexOf(selectString);
                        if (indexOfSelect != -1) {
                            sub_dynamicQuery = this.parseQueryToDynamic(subQuery);
                        }
                        return { SubDynamicQuery: sub_dynamicQuery, RemainingQuery: remainingQuery, SubQueryAliasName: subQueryAliasName };
                    }
                    getTablesJoinsClauses(tempQuery) {
                        tempQuery = tempQuery.toLowerCase().trim();
                        let joinsArr = new Array();
                        let clauseArr = new Array();
                        let whereArr = new Array();
                        let tables = new Array();
                        let whereStr = "where ";
                        let orderByStr = "order by";
                        let groupByStr = "group by";
                        let havingStr = "having ";
                        let whereConditionStr = "";
                        let groupByConditionStr = "";
                        let havingConditionStr = "";
                        let orderByConditionStr = "";
                        let tablesQuery = "";
                        let joinsArray = [];
                        let lastRelation = "";
                        let relations = Object.values(DataSources.Enums.RelationType).filter(x => typeof (x) == "string");
                        let whereIdx = tempQuery.indexOf(whereStr) == -1 ? Infinity : tempQuery.indexOf(whereStr);
                        let groubyIdx = tempQuery.indexOf(groupByStr) == -1 ? Infinity : tempQuery.indexOf(groupByStr);
                        let orderbyIdx = tempQuery.indexOf(orderByStr) == -1 ? Infinity : tempQuery.indexOf(orderByStr);
                        let havingIdx = tempQuery.indexOf(havingStr) == -1 ? Infinity : tempQuery.indexOf(havingStr);
                        let clauseIdx = Math.min(whereIdx, groubyIdx, orderbyIdx, havingIdx);
                        if (clauseIdx != Infinity)
                            tablesQuery = tempQuery.substring(0, clauseIdx);
                        else
                            tablesQuery = tempQuery;
                        lastRelation = relations.pop();
                        joinsArray = tablesQuery.split(lastRelation.toLowerCase()).map(x => x.trim());
                        if (joinsArray.length > 1) {
                            for (var i = 0; i < joinsArray.length; i++) {
                                if (i && !joinsArray[i].startsWith("__")) {
                                    joinsArray[i] = `__Cross ` + joinsArray[i];
                                }
                            }
                        }
                        for (var i = 0; i < relations.length; i++) {
                            for (var j = 0; j < joinsArray.length; j++) {
                                let split = joinsArray[j].split(relations[i].toLowerCase()).map(x => x.trim());
                                if (split.length > 1) {
                                    joinsArray.splice(j, 1);
                                    for (var k = 0; k < split.length; k++) {
                                        joinsArray.splice(j + k, 0, split[k]);
                                    }
                                }
                            }
                            if (joinsArray.length > 1) {
                                for (var j = 0; j < joinsArray.length; j++) {
                                    if (j && !joinsArray[j].startsWith("__")) {
                                        joinsArray[j] = `__${relations[i]} ` + joinsArray[j];
                                    }
                                }
                            }
                        }
                        for (var j = 0; j < joinsArray.length; j++) {
                            let currentEle = joinsArray[j];
                            let index = currentEle.indexOf(" join ", 8);
                            if (index != -1) {
                                joinsArray.splice(j + 1, 0, "__Inner" + currentEle.substring(index, currentEle.length));
                                joinsArray[j] = currentEle.substring(0, index);
                            }
                        }
                        for (var j = 0; j < joinsArray.length; j++) {
                            let table = new DataSources.Requests.DataListTable();
                            let join = new DataSources.Requests.DataListJoin();
                            let joinOn = new DataSources.Requests.DataListJoinOn();
                            if (!j) {
                                let minIdx = Math.min(whereIdx, groubyIdx, orderbyIdx, havingIdx);
                                if (minIdx != Infinity)
                                    joinsArray[j] = joinsArray[j].substring(0, minIdx);
                                let tableArr = [];
                                if (joinsArray[j].includes("(")) {
                                    tableArr = [joinsArray[j]];
                                }
                                else {
                                    tableArr = joinsArray[j].split(" ");
                                    if (joinsArray[j].includes("as "))
                                        tableArr = joinsArray[j].split("as ").map(x => x.trim());
                                }
                                join.DocTypeTableName = tableArr[0];
                                join.DocTableAliasName = tableArr[1] ? tableArr[1] : tableArr[0];
                                table.DocTypeTableName = tableArr[0];
                                table.DocTableAliasName = tableArr[1] ? tableArr[1] : tableArr[0];
                            }
                            else {
                                if (joinsArray[j].includes("join "))
                                    joinsArray[j] = joinsArray[j].replace("join ", "");
                                let joinType = joinsArray[j].split(" ")[0].slice(2);
                                join.DocJoinType = parseInt(DataSources.Enums.RelationType[joinType]);
                                joinsArray[j] = joinsArray[j].split(" ").slice(1).join(" ");
                                let joinArr = joinsArray[j].split(" on ");
                                let tableSplit = joinArr[0].split(" ").map(x => x.trim());
                                let tableColumnsSplit = joinArr[1].split("=").map(x => x.trim());
                                if (tableSplit.length == 2) {
                                    join.DocTypeTableName = tableSplit[0];
                                    join.DocTableAliasName = tableSplit[1];
                                    table.DocTypeTableName = tableSplit[0];
                                    table.DocTableAliasName = tableSplit[1];
                                }
                                else {
                                    join.DocTypeTableName = tableSplit[0];
                                    join.DocTableAliasName = tableSplit[0];
                                    table.DocTypeTableName = tableSplit[0];
                                    table.DocTableAliasName = tableSplit[0];
                                }
                                joinOn.DocTypeTable1Column = tableColumnsSplit[0];
                                joinOn.DocTypeTable2Column = tableColumnsSplit[1];
                                join.on = joinOn;
                            }
                            joinsArr.push(join);
                            tables.push(table);
                        }
                        whereIdx = tempQuery.indexOf(whereStr) == -1 ? Infinity : tempQuery.indexOf(whereStr);
                        groubyIdx = tempQuery.indexOf(groupByStr) == -1 ? Infinity : tempQuery.indexOf(groupByStr);
                        orderbyIdx = tempQuery.indexOf(orderByStr) == -1 ? Infinity : tempQuery.indexOf(orderByStr);
                        havingIdx = tempQuery.indexOf(havingStr) == -1 ? Infinity : tempQuery.indexOf(havingStr);
                        if (whereIdx != Infinity) {
                            let minIdx = Math.min(groubyIdx, orderbyIdx, havingIdx) == Infinity ? tempQuery.length : Math.min(groubyIdx, orderbyIdx, havingIdx);
                            whereConditionStr = tempQuery.substring(whereIdx + 5, minIdx).trim();
                            whereArr = this.getWhereConditionsFromQuery(whereConditionStr);
                        }
                        if (groubyIdx != Infinity) {
                            let clause = new DataSources.Requests.DataListClause();
                            let minIdx = Math.min(orderbyIdx, havingIdx) == Infinity ? tempQuery.length : Math.min(orderbyIdx, havingIdx);
                            groupByConditionStr = tempQuery.substring(groubyIdx + 8, minIdx).trim();
                            clause.ClauseType = DataSources.Enums.ClauseType.GroupBy;
                            clause.Columns = groupByConditionStr;
                            clauseArr.push(clause);
                        }
                        if (havingIdx != Infinity) {
                            let clause = new DataSources.Requests.DataListClause();
                            havingConditionStr = tempQuery.substring(havingIdx + 6, orderbyIdx == Infinity ? tempQuery.length : orderbyIdx).trim();
                            clause.ClauseType = DataSources.Enums.ClauseType.Having;
                            clause.Columns = "";
                            clause.Having = this.getWhereConditionsFromQuery(whereConditionStr);
                            clauseArr.push(clause);
                        }
                        if (orderbyIdx != Infinity) {
                            let clause = new DataSources.Requests.DataListClause();
                            let orderByArr = Object.values(DataSources.Enums.OrderBy).filter(x => typeof (x) == "string");
                            orderByConditionStr = tempQuery.substring(orderbyIdx + 8, tempQuery.length).trim();
                            clause.ClauseType = DataSources.Enums.ClauseType.OrderBy;
                            clause.Columns = orderByConditionStr;
                            for (var i = 0; i < orderByArr.length; i++) {
                                if (orderByConditionStr.includes(orderByArr[i].toLowerCase()))
                                    clause.OrderBy = parseInt(DataSources.Enums.OrderBy[orderByArr[i]]);
                            }
                            clauseArr.push(clause);
                        }
                        return { Tables: tables, Joins: joinsArr, Where: whereArr, Clause: clauseArr };
                    }
                    getIndexOfCorrespondingCloseBracket(query) {
                        let counter = 1;
                        let openBrac = "(";
                        let closeBrac = ")";
                        let index = 1;
                        while (counter > 0) {
                            let openIndex = query.indexOf(openBrac, index);
                            let closeIndex = query.indexOf(closeBrac, index);
                            if (openIndex != -1 && closeIndex != -1) {
                                if (openIndex < closeIndex) {
                                    counter++;
                                    index = openIndex + 1;
                                }
                                else if (openIndex > closeIndex) {
                                    counter--;
                                    index = closeIndex + 1;
                                }
                            }
                            else if (openIndex == -1 && closeIndex != -1) {
                                counter--;
                                index = closeIndex + 1;
                            }
                            else if (closeIndex == -1) {
                            }
                        }
                        return index;
                    }
                    getDataListColumnsFromSelectString(query) {
                        let columns = new Array();
                        let indexOfSelect = query.indexOf("select ");
                        let indexOfFrom = query.indexOf("from ");
                        let columnsStr = "";
                        if (indexOfSelect != -1 && indexOfFrom != -1) {
                            columnsStr = query.trim().substring(indexOfSelect + 6, indexOfFrom).trim();
                            columnsStr.indexOf(",") == 0 && (columnsStr = columnsStr.slice(1));
                            columnsStr = this.removeParanthesisBetweenColumns(columnsStr);
                            if (columnsStr.length) {
                                let colsArray = columnsStr.trim().split(",").map(x => x.trim());
                                for (var i = 0; i < colsArray.length; i++) {
                                    let column = new DataSources.Requests.DataListColumn();
                                    if (colsArray[i].includes(" as")) {
                                        let col_alias = colsArray[i].split(" as").map(x => x.trim());
                                        column.ColumnName = col_alias[0];
                                        column.AliasName = col_alias[1];
                                    }
                                    else {
                                        let clmn = colsArray[i].trim();
                                        column.ColumnName = clmn;
                                        column.AliasName = clmn;
                                    }
                                    columns.push(column);
                                }
                            }
                        }
                        columns = this.addParanthesisBtwColumns(columns);
                        return columns;
                    }
                    getWhereConditionsFromQuery(query) {
                        query = query.trim().toLowerCase();
                        let splitedArray = this.getWhereQueryAsConditionsArray(query);
                        let WhereArr = new Array();
                        for (var i = 0; i < splitedArray.length; i++) {
                            let where = new DataSources.Requests.DataListWhere();
                            if (i) {
                                let clmnSplit = splitedArray[i].split(" ");
                                clmnSplit.shift();
                                splitedArray[i] = clmnSplit.join(" ");
                            }
                            if (splitedArray[i].includes("between ")) {
                                let split = splitedArray[i].split(" ");
                                where.ColumnName = split[0];
                                where.IsBetween = true;
                                where.Value1 = split[2];
                                where.Value2 = split[4];
                                where.ExpressionType = DataSources.Enums.ExpressionType.Between;
                            }
                            else if (splitedArray[i].includes(">=")) {
                                let split = splitedArray[i].split(">=");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.GreaterThanEqualTo;
                            }
                            else if (splitedArray[i].includes("<=")) {
                                let split = splitedArray[i].split("<=");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.LessThanEqualTo;
                            }
                            else if (splitedArray[i].includes("!=")) {
                                let split = splitedArray[i].split("!=");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.NotEqualTo;
                            }
                            else if (splitedArray[i].includes(">")) {
                                let split = splitedArray[i].split(">");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.GreaterThan;
                            }
                            else if (splitedArray[i].includes("<")) {
                                let split = splitedArray[i].split("<");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.LessThan;
                            }
                            else if (splitedArray[i].includes("=")) {
                                let split = splitedArray[i].split("=");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.EqualTo;
                            }
                            else if (splitedArray[i].includes("not in ")) {
                                let split = splitedArray[i].split("not in ");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.NotIn;
                            }
                            else if (splitedArray[i].includes(" in")) {
                                let split = splitedArray[i].split(" in");
                                if (split.length > 2)
                                    split[1] = split.slice(1).join(" ");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.In;
                            }
                            else if (splitedArray[i].includes("is not")) {
                                let split = splitedArray[i].split("is not");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.IsNotNull;
                            }
                            else if (splitedArray[i].includes(" is")) {
                                let split = splitedArray[i].split(" is");
                                where.ColumnName = split[0].trim();
                                where.Value1 = split[1].trim();
                                where.ExpressionType = DataSources.Enums.ExpressionType.IsNull;
                            }
                            if (i + 1 < splitedArray.length) {
                                where.AddConditionType = DataSources.Enums.ConditionJoinType[(splitedArray[i + 1].split(" ").shift().slice(2))];
                            }
                            WhereArr.push(where);
                        }
                        return WhereArr;
                    }
                    removeParanthesisBetweenColumns(columnsStr) {
                        let openPranStr = "(";
                        let indexOfOpenPranthesis = columnsStr.indexOf(openPranStr);
                        let indexOfClosedParan = -1;
                        let strBtwnParanthesis = "";
                        let modifiedStr = "";
                        let tempStr = "";
                        while (indexOfOpenPranthesis != -1) {
                            tempStr = columnsStr.substring(indexOfOpenPranthesis + 1, columnsStr.length);
                            indexOfClosedParan = this.getIndexOfCorrespondingCloseBracket(tempStr);
                            strBtwnParanthesis = columnsStr.substring(indexOfOpenPranthesis, indexOfOpenPranthesis + indexOfClosedParan + 1);
                            modifiedStr = strBtwnParanthesis.replaceAll(openPranStr, "_& ");
                            modifiedStr = modifiedStr.replaceAll(",", "__");
                            modifiedStr = modifiedStr.replaceAll(")", " &_");
                            columnsStr = columnsStr.replace(strBtwnParanthesis, modifiedStr);
                            indexOfOpenPranthesis = columnsStr.indexOf(openPranStr);
                        }
                        return columnsStr;
                    }
                    addParanthesisBtwColumns(columns) {
                        for (var i = 0; i < columns.length; i++) {
                            let colname = columns[i].ColumnName;
                            let aliasName = columns[i].AliasName;
                            if (colname.includes("_& ")) {
                                colname = colname.replaceAll("_& ", "(");
                                colname = colname.replaceAll("__", ",");
                                colname = colname.replaceAll(" &_", ")");
                                aliasName = aliasName.replaceAll("_& ", "(");
                                aliasName = aliasName.replaceAll("__", ",");
                                aliasName = aliasName.replaceAll(" &_", ")");
                                columns[i].ColumnName = colname;
                                columns[i].AliasName = aliasName;
                            }
                        }
                        return columns;
                    }
                    getUnionsAndRemainingQuery(tempQuery) {
                        tempQuery = tempQuery.trim();
                        let unionQuery;
                        let currentRmngQuery = "";
                        let newUnionQuery = "";
                        let unionIdx;
                        let unionAllIdx;
                        let unionType;
                        let isUnion;
                        unionAllIdx = tempQuery.indexOf(" union all") == -1 ? Infinity : tempQuery.indexOf(" union all");
                        unionIdx = tempQuery.indexOf(" union") == -1 ? Infinity : tempQuery.indexOf(" union");
                        if (unionIdx < unionAllIdx) {
                            currentRmngQuery = tempQuery.substring(0, unionIdx);
                            newUnionQuery = tempQuery.substring(unionIdx + 6, tempQuery.length);
                            unionType = DataSources.Enums.UnionType.Union;
                        }
                        else if (unionIdx > unionAllIdx) {
                            currentRmngQuery = tempQuery.substring(0, unionAllIdx);
                            newUnionQuery = tempQuery.substring(unionAllIdx + 10, tempQuery.length);
                            unionType = DataSources.Enums.UnionType.UnionAll;
                        }
                        unionQuery = this.parseQueryToDynamic(newUnionQuery);
                        isUnion = true;
                        return { UnionType: unionType, IsUnion: isUnion, UnionQuery: unionQuery, CurrentRmngQuery: currentRmngQuery };
                    }
                    getWhereQueryAsConditionsArray(query) {
                        var splitArray = query.split("and ");
                        var keywords = ["and ", "or "];
                        if (splitArray.length > 1) {
                            for (var i = 0; i < splitArray.length; i++) {
                                if (i && !splitArray[i].startsWith("__")) {
                                    splitArray[i] = `__And ` + splitArray[i];
                                }
                            }
                        }
                        keywords.shift();
                        for (var i = 0; i < keywords.length; i++) {
                            for (var j = 0; j < splitArray.length; j++) {
                                let split = splitArray[j].split((keywords[i]).toLowerCase()).map(x => x.trim());
                                if (split.length > 1) {
                                    splitArray.splice(j, 1);
                                    for (var k = 0; k < split.length; k++) {
                                        splitArray.splice(j + k, 0, split[k]);
                                    }
                                }
                            }
                            for (var k = 0; k < splitArray.length; k++) {
                                if (k && !splitArray[k].startsWith("__")) {
                                    splitArray[k] = `__Or ` + splitArray[k];
                                }
                            }
                        }
                        splitArray = splitArray.map(x => x.trim());
                        for (var i = 0; i < splitArray.length; i++) {
                            if (splitArray[i].includes("between ")) {
                                let nextElemntArr = splitArray[i + 1].split(" ");
                                nextElemntArr.shift();
                                splitArray[i + 1] = nextElemntArr.map(x => x.trim()).join(" ");
                                splitArray[i] = splitArray[i] + " and " + splitArray[i + 1];
                                splitArray.splice(i + 1, 1);
                            }
                        }
                        return splitArray;
                    }
                    someFn(joinArr) {
                        if (joinArr.length == 3 && joinArr[2].includes("=")) {
                            let tablesSeperatedArr = joinArr[2].split("=");
                            joinArr.splice(2, 1);
                            for (var l = 0; l < tablesSeperatedArr.length; l++) {
                                joinArr.push(tablesSeperatedArr[l]);
                                if (!l)
                                    joinArr.push("=");
                            }
                        }
                        else if (joinArr.length == 4 && joinArr[2].includes("=")) {
                            joinArr[2] = joinArr[2].replace("=", "");
                            joinArr.splice(3, 0, "=");
                        }
                        else if (joinArr.length == 4 && joinArr[3].includes("=")) {
                            joinArr[3] = joinArr[3].replace("=", "");
                            joinArr.splice(3, 0, "=");
                        }
                        else if (joinArr.length == 4 && joinArr[3].includes("=")) {
                            let tablesSeperatedArr = joinArr[3].split("=");
                            joinArr.splice(3, 1);
                            for (var l = 0; l < tablesSeperatedArr.length; l++) {
                                joinArr.push(tablesSeperatedArr[l]);
                                if (!l)
                                    joinArr.push("=");
                            }
                        }
                        else if (joinArr.length == 4 && joinArr[2].includes("=")) {
                            joinArr[2] = joinArr[2].replace("=", "");
                            joinArr.splice(3, 0, "=");
                        }
                        else if (joinArr.length == 4 && joinArr[3].includes("=")) {
                            joinArr[3] = joinArr[3].replace("=", "");
                            joinArr.splice(3, 0, "=");
                        }
                        return joinArr;
                    }
                    getSubQueriesInWhere(clauseQuery) {
                        clauseQuery = clauseQuery.trim();
                        let whereIdx;
                        let groubyIdx;
                        let orderbyIdx;
                        let havingIdx;
                        let clauseIdx;
                        let unionIdx;
                        let whereQuery = "";
                        let queryBfWhr = "";
                        let tempQuery = "";
                        let closingIdx;
                        let selectIdx;
                        let subQueryStr = "";
                        let whereInitialStr = "";
                        let otherClauseQuery = "";
                        let subQueryArr = [];
                        let whereArr = [];
                        selectIdx = clauseQuery.indexOf("select ");
                        while (selectIdx != -1) {
                            let subquery = new DataSources.Requests.DynamicQuery();
                            whereInitialStr = clauseQuery.substring(0, selectIdx).trim();
                            whereInitialStr = whereInitialStr.substring(0, whereInitialStr.lastIndexOf("(")).trim();
                            tempQuery = clauseQuery.substring(selectIdx, clauseQuery.length);
                            closingIdx = this.getIndexOfCorrespondingCloseBracket(tempQuery);
                            subQueryStr = tempQuery.substring(0, closingIdx - 1);
                            clauseQuery = tempQuery.substring(closingIdx, tempQuery.length).trim();
                            selectIdx = subQueryStr.indexOf("select ");
                            if (selectIdx != -1) {
                                subquery = this.parseQueryToDynamic(subQueryStr);
                            }
                            clauseQuery = whereInitialStr + ` __subquerytable_${++this.subQueryNumber} ` + clauseQuery;
                            selectIdx = clauseQuery.indexOf("select ");
                            unionIdx = clauseQuery.indexOf("union ");
                            if (unionIdx < selectIdx)
                                selectIdx = -1;
                            subquery.TempName = `__subquerytable_${this.subQueryNumber}`;
                            subQueryArr.push(subquery);
                        }
                        groubyIdx = clauseQuery.indexOf("group by") == -1 ? Infinity : clauseQuery.indexOf("group by");
                        orderbyIdx = clauseQuery.indexOf("order by") == -1 ? Infinity : clauseQuery.indexOf("order by");
                        havingIdx = clauseQuery.indexOf("having ") == -1 ? Infinity : clauseQuery.indexOf("having ");
                        unionIdx = clauseQuery.indexOf("union ") == -1 ? Infinity : clauseQuery.indexOf("union ");
                        clauseIdx = Math.min(groubyIdx, orderbyIdx, havingIdx, unionIdx);
                        whereIdx = clauseQuery.indexOf("where ");
                        if (clauseIdx != Infinity) {
                            whereQuery = clauseQuery.substring(clauseQuery.indexOf("where ") + 6, clauseIdx);
                            otherClauseQuery = clauseQuery.substring(clauseIdx, clauseQuery.length);
                        }
                        else {
                            whereQuery = clauseQuery.substring(clauseQuery.indexOf("where ") + 6, clauseQuery.length);
                        }
                        whereQuery = whereQuery.trim();
                        let idx = whereQuery.indexOf("(");
                        if (idx == 0) {
                            let clseIdx = this.getIndexOfCorrespondingCloseBracket(whereQuery.slice(idx));
                            whereQuery = whereQuery.substring(0, clseIdx - 1).slice(idx + 1).trim();
                        }
                        queryBfWhr = clauseQuery.substring(0, whereIdx);
                        otherClauseQuery = otherClauseQuery.replace(whereQuery, "").trim();
                        otherClauseQuery = queryBfWhr + otherClauseQuery;
                        whereArr = this.getWhereConditionsFromQuery(whereQuery);
                        for (var i = 0; i < whereArr.length; i++) {
                            let subQuery = subQueryArr.find(x => x.TempName == whereArr[i].Value1);
                            if (subQuery) {
                                whereArr[i].IsSubQuery = true;
                                whereArr[i].SubQuery = subQuery;
                            }
                        }
                        return { listOfWhere: whereArr, RemaingQuery: otherClauseQuery };
                    }
                    static Instance() {
                        if (this.instance === undefined) {
                            this.instance = new QueryParser();
                        }
                        return this.instance;
                    }
                }
                Components.QueryParser = QueryParser;
            })(Components = DataSources.Components || (DataSources.Components = {}));
        })(DataSources = Platform.DataSources || (Platform.DataSources = {}));
    })(Platform = Unibase.Platform || (Unibase.Platform = {}));
})(Unibase || (Unibase = {}));