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 `
${this.getAddColumnHtml()}
${this.getTableHtml()}
${this.getInitialWhereHtml(sub_query_cls)}
${this.getInitialClauseHtml(sub_query_cls)}
${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 `
As
`;
}
getTableHtml() {
return ``;
}
getJoinDropDown() {
return ``;
}
getJoinHtml() {
return ``;
}
getInitialWhereHtml(cls) {
return `
Where
${this.getWhereHtml(cls)}
`;
}
getWhereHtml(cls) {
return ` `;
}
getBetweenHtml() {
return ` And
`;
}
getInitialClauseHtml(cls) {
return `
Clause
${this.getClauseHtml()}
`;
}
getClauseDwnHtml() {
return ``;
}
getClauseHtml() {
return `
${this.getClauseDwnHtml()}
${this.getOrderByAggregationHtml()}
${this.getHavingClauseHtml()}
`;
}
getOrderByAggregationHtml() {
return `
`;
}
getGroupByClauseHtml() {
return ``;
}
getHavingClauseHtml() {
return `
${this.getBetweenHtml()}
`;
}
getUnionDropDwnHtml() {
return ``;
}
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 ``;
}
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 += ``;
}
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 = {}));