database-builder
Version:
Library to assist in creating and maintaining SQL commands.
391 lines (390 loc) • 18.7 kB
JavaScript
"use strict";
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.WhereBaseBuilder = void 0;
var utils_1 = require("../core/utils");
var condition_1 = require("./enums/condition");
var database_helper_1 = require("../database-helper");
var errors_1 = require("../core/errors");
var column_ref_1 = require("../core/column-ref");
var projections_helper_1 = require("../core/projections-helper");
var query_helper_1 = require("../core/query-helper");
var plan_ref_1 = require("../core/plan-ref");
var WhereBaseBuilder = /** @class */ (function () {
function WhereBaseBuilder(
// TODO: verificar e se é possivel remover declaração de tipo de instancia, é usar apenas o generics,
// pois o join está passando "void 0" e declarando apenas o generics
_typeT, _alias) {
this._typeT = _typeT;
this._alias = _alias;
this._where = "";
this._params = [];
this._pendingConditions = [];
this._pendingAndOr = WhereBaseBuilder.AND;
this._databaseHelper = new database_helper_1.DatabaseHelper();
}
WhereBaseBuilder.prototype.proj = function () {
return new projections_helper_1.ProjectionsHelper(this._typeT, this._alias, false);
};
WhereBaseBuilder.prototype.concat = function () {
var _a;
var projections = [];
for (var _i = 0; _i < arguments.length; _i++) {
projections[_i] = arguments[_i];
}
return (_a = this.proj()).concat.apply(_a, __spreadArray([""], projections, false));
};
WhereBaseBuilder.prototype.coalesce = function (expression, argumentsCoalesce, alias, args
// expression: ExpressionOrColumn<TReturn, T>,
// // alias?: string,
// ...args: any[]
) {
if (alias === void 0) { alias = ""; }
return this.proj().coalesce(expression, argumentsCoalesce, alias, args);
};
WhereBaseBuilder.prototype.ref = function (expression, alias) {
if (alias === void 0) { alias = this._alias; }
return new column_ref_1.ColumnRef(utils_1.Utils.getColumn(expression), alias);
};
WhereBaseBuilder.prototype.not = function () {
this._pendingConditions.push(condition_1.Condition.Not);
return this._getInstance();
};
WhereBaseBuilder.prototype.and = function () {
this._pendingAndOr = WhereBaseBuilder.AND;
return this._getInstance();
};
WhereBaseBuilder.prototype.or = function () {
this._pendingAndOr = WhereBaseBuilder.OR;
return this._getInstance();
};
WhereBaseBuilder.prototype.scope = function (scopeCallback) {
var instanceScope = this._create(this._typeT, this._alias);
scopeCallback(instanceScope);
this.compileScope(instanceScope.compile());
return this._getInstance();
};
/**
* @deprecated Use `equal`
* @param expression
* @param column
*/
WhereBaseBuilder.prototype.equalColumn = function (expression, column) {
this.buildWhereColumn([condition_1.Condition.Equal], this.getColumnParams(expression), column);
return this._getInstance();
};
/**
* @deprecated use `equal`
*/
WhereBaseBuilder.prototype.equalValue = function (expression, value) {
this.buildWhereColumn([condition_1.Condition.Equal], this.getColumnParams(expression), [value]);
return this._getInstance();
};
WhereBaseBuilder.prototype.equal = function (expression1, expression2) {
this.buildWhereColumn([condition_1.Condition.Equal], this.getColumnParams(expression1), this.getColumnParams(expression2));
return this._getInstance();
};
/**
* @deprecated use `like`
*/
WhereBaseBuilder.prototype.likeValue = function (expression, value) {
this.buildWhereColumn([condition_1.Condition.Like], this.getColumnParams(expression), [value]);
return this._getInstance();
};
WhereBaseBuilder.prototype.like = function (expression1, expression2) {
this.buildWhereColumn([condition_1.Condition.Like], this.getColumnParams(expression1), this.getColumnParams(expression2));
return this._getInstance();
};
WhereBaseBuilder.prototype.multiColumnLike = function (like, separator) {
var _this = this;
var columns = [];
for (var _i = 2; _i < arguments.length; _i++) {
columns[_i - 2] = arguments[_i];
}
var columnsExpression = columns
.map(function (column) { return _this.getColumnParams(column); })
.map(function (_a) {
var column = _a.column, params = _a.params;
return _this.coalesce(query_helper_1.QueryHelper.compileWithoutParams(utils_1.Utils.addAlias(column, _this._alias), params.map(function (param) { return utils_1.Utils.getDatabaseHelper().parseToValueType(param); })), ['']).resultWithoutParams()[0];
})
.join(" || '".concat(separator, "' || "));
this.contains(new plan_ref_1.PlanRef(columnsExpression), like.toUpperCase());
return this._getInstance();
};
WhereBaseBuilder.prototype.contains = function (expression, value) {
return this.likeValue(expression, "%".concat(value, "%"));
};
WhereBaseBuilder.prototype.startsWith = function (expression, value) {
return this.likeValue(expression, "".concat(value, "%"));
};
WhereBaseBuilder.prototype.endsWith = function (expression, value) {
return this.likeValue(expression, "%".concat(value));
};
WhereBaseBuilder.prototype.isNull = function (expression1) {
this.buildWhereColumn([condition_1.Condition.IsNull], this.getColumnParams(expression1), void 0);
return this._getInstance();
};
/**
* @deprecated use `great`
*/
WhereBaseBuilder.prototype.greatValue = function (expression, value) {
this.buildWhereColumn([condition_1.Condition.Great], this.getColumnParams(expression), [value]);
return this._getInstance();
};
WhereBaseBuilder.prototype.great = function (expression1, expression2) {
this.buildWhereColumn([condition_1.Condition.Great], this.getColumnParams(expression1), this.getColumnParams(expression2));
return this._getInstance();
};
/**
* @deprecated use `greatAndEqual`
*/
WhereBaseBuilder.prototype.greatAndEqualValue = function (expression, value) {
this.buildWhereColumn([condition_1.Condition.GreatAndEqual], this.getColumnParams(expression), [value]);
return this._getInstance();
};
WhereBaseBuilder.prototype.greatAndEqual = function (expression1, expression2) {
this.buildWhereColumn([condition_1.Condition.GreatAndEqual], this.getColumnParams(expression1), this.getColumnParams(expression2));
return this._getInstance();
};
/**
* @deprecated use `less`
*/
WhereBaseBuilder.prototype.lessValue = function (expression, value) {
this.buildWhereColumn([condition_1.Condition.Less], this.getColumnParams(expression), [value]);
return this._getInstance();
};
WhereBaseBuilder.prototype.less = function (expression1, expression2) {
this.buildWhereColumn([condition_1.Condition.Less], this.getColumnParams(expression1), this.getColumnParams(expression2));
return this._getInstance();
};
/**
* @deprecated use `lessAndEqual`
*/
WhereBaseBuilder.prototype.lessAndEqualValue = function (expression, value) {
this.buildWhereColumn([condition_1.Condition.LessAndEqual], this.getColumnParams(expression), [value]);
return this._getInstance();
};
WhereBaseBuilder.prototype.lessAndEqual = function (expression1, expression2) {
this.buildWhereColumn([condition_1.Condition.LessAndEqual], this.getColumnParams(expression1), this.getColumnParams(expression2));
return this._getInstance();
};
/**
* @deprecated use `between`
*/
WhereBaseBuilder.prototype.betweenValue = function (expression, value1, value2) {
return this.between(expression, value1, value2);
};
WhereBaseBuilder.prototype.between = function (expression, startExpression, endExpression
// value1: ValueTypeToParse,
// value2: ValueTypeToParse,
) {
this.buildWhereColumn([condition_1.Condition.Between], this.getColumnParams(expression), this.getColumnParams(startExpression), this.getColumnParams(endExpression));
// [startExpression, endExpression]);
return this._getInstance();
};
/**
* @deprecated use `in`
*/
WhereBaseBuilder.prototype.inValues = function (expression, values) {
return this.in(expression, values);
};
WhereBaseBuilder.prototype.in = function (expression, valuesOrQuery) {
var _this = this;
if (utils_1.Utils.isArray(valuesOrQuery)) {
this.buildWhereColumn([condition_1.Condition.In], this.getColumnParams(expression), valuesOrQuery);
}
else {
var compileds = valuesOrQuery.compile();
compileds.forEach(function (compiled) {
_this.buildWhereColumn([condition_1.Condition.In], _this.getColumnParams(expression), compiled.query);
_this.addParam(compiled.params);
});
}
return this._getInstance();
};
/**
* @deprecated use `in`
*/
WhereBaseBuilder.prototype.inSelect = function (expression, query) {
return this.in(expression, query);
};
WhereBaseBuilder.prototype.compile = function () {
return {
params: this._params,
where: this._where,
};
};
WhereBaseBuilder.prototype.expression = function (expression) {
var metadata = utils_1.Utils.getLambdaMetadata(expression);
this.buildWhereMetadata(metadata);
return this._getInstance();
};
WhereBaseBuilder.prototype._addParams = function (params) {
this._params = this._params.concat(params);
return this._getInstance();
};
WhereBaseBuilder.prototype.buildWhereWithExpressionOrValue = function (condition, expression1, expression2) {
var column1 = this.getColumnParams(expression1);
var column2 = this.getColumnParams(expression2);
this.buildWhereColumn(condition, column1, column2);
};
WhereBaseBuilder.prototype.buildWhereColumn = function (condition) {
var _this = this;
var valuesOrColumns = [];
for (var _i = 1; _i < arguments.length; _i++) {
valuesOrColumns[_i - 1] = arguments[_i];
}
var columnsParams = valuesOrColumns.map(function (x) { return _this.processParam(x); });
this.buildWhereParams(condition, columnsParams.map(function (x) { return utils_1.Utils.addAlias(x.column, _this._alias); }), columnsParams.map(function (value) { return value.params; })
// alternative Array.flat()
// https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array/flat#Alternativa
.reduce(function (acc, val) { return acc.concat(val); }, []));
};
WhereBaseBuilder.prototype.buildWhereParams = function (condition, columns, params) {
this.buildWhere(condition, columns);
this.addParam(params);
};
WhereBaseBuilder.prototype.buildWhere = function (conditions, columns) {
this.checkWhere();
this._where += this.createWhere(conditions, columns);
};
WhereBaseBuilder.prototype.addParam = function (param) {
var _this = this;
if (Array.isArray(param)) {
param.forEach(function (value) {
_this.addValueParam(value);
});
}
else {
this.addValueParam(param);
}
};
WhereBaseBuilder.prototype.processParam = function (param) {
if (utils_1.Utils.isNull(param)) {
return {
column: void 0,
params: []
};
}
if (Array.isArray(param)) {
var result_1 = {
column: "",
params: []
};
param.forEach(function (value) {
result_1.column += result_1.column.length > 0 ? ", ?" : "?";
result_1.params.push(value);
});
return result_1;
}
if (utils_1.Utils.isString(param)) {
return {
column: param,
params: []
};
}
return param;
};
WhereBaseBuilder.prototype.buildWhereMetadata = function (metadata) {
if (!utils_1.Utils.isNameColumn(metadata.left) && utils_1.Utils.isValue(metadata.left)) {
this.addParam(utils_1.Utils.clearParamLambda(metadata.left));
metadata.left = "?";
}
if (!utils_1.Utils.isNameColumn(metadata.right) && utils_1.Utils.isValue(metadata.right)) {
this.addParam(utils_1.Utils.clearParamLambda(metadata.right));
metadata.right = "?";
}
this.buildWhere(metadata.condition, [utils_1.Utils.addAlias(metadata.left, this._alias), utils_1.Utils.addAlias(metadata.right, this._alias)]);
};
WhereBaseBuilder.prototype.addValueParam = function (param) {
this._params.push(this._databaseHelper.parseToValueType(utils_1.Utils.clearParam(param)));
};
WhereBaseBuilder.prototype.createWhere = function (conditions, columns) {
// TODO: verificar se colunas não são condition, para remover a condition
var conditionsArray = this._pendingConditions.concat(conditions);
this._pendingConditions = [];
if (columns.length === 2) {
var isConditionIsNullInColumn2 = columns[1] === condition_1.Condition.IsNull;
if (isConditionIsNullInColumn2) {
conditionsArray = this.conditionIsNull(conditionsArray);
columns.pop();
}
}
return this.buildConditions(conditionsArray, columns);
};
WhereBaseBuilder.prototype.conditionIsNull = function (currentConditions) {
// new scope
if (!currentConditions || (currentConditions.length === 1 && utils_1.Utils.isNull(currentConditions[0]))) {
return [condition_1.Condition.IsNull];
}
switch (currentConditions.toString()) {
case [condition_1.Condition.Equal].toString():
return [condition_1.Condition.IsNull];
case [condition_1.Condition.Not, condition_1.Condition.Equal].toString():
return [condition_1.Condition.Not, condition_1.Condition.IsNull];
default:
return currentConditions;
}
};
WhereBaseBuilder.prototype.buildConditions = function (conditions, columns) {
// new scope
if (!conditions || (conditions.length === 1 && utils_1.Utils.isNull(conditions[0]))) {
return "(".concat(columns[0], ")");
}
switch (conditions.toString()) {
case [condition_1.Condition.Between].toString():
case [condition_1.Condition.Not, condition_1.Condition.Between].toString():
// ${column} BETWEEN ${columnOrParam} AND ${columnOrParam}
if (columns.length === 3) {
return "".concat(columns[0], " ").concat(this.builderConditions(conditions), " ").concat(columns[1], " ").concat(WhereBaseBuilder.AND, " ").concat(columns[2]);
}
throw new errors_1.DatabaseBuilderError("Length (".concat(columns.length, ") (values: ").concat(columns, ") parameter to '").concat(conditions, "' condition incorrect!"));
case [condition_1.Condition.In].toString():
case [condition_1.Condition.Not, condition_1.Condition.In].toString():
// ${column} IN (?, ?, ...)
return "".concat(columns[0], " ").concat(this.builderConditions(conditions), " (").concat(columns[1], ")").trim();
case [condition_1.Condition.Not, condition_1.Condition.IsNull].toString():
return "".concat(columns[0], " IS NOT NULL").trim();
case [condition_1.Condition.Not, condition_1.Condition.Equal].toString():
return "".concat(columns[0], " <> ").concat(columns[1]).trim();
case [condition_1.Condition.Not, condition_1.Condition.Great].toString():
return this.buildConditions([condition_1.Condition.LessAndEqual], columns);
case [condition_1.Condition.Not, condition_1.Condition.GreatAndEqual].toString():
return this.buildConditions([condition_1.Condition.Less], columns);
case [condition_1.Condition.Not, condition_1.Condition.Less].toString():
return this.buildConditions([condition_1.Condition.GreatAndEqual], columns);
case [condition_1.Condition.Not, condition_1.Condition.LessAndEqual].toString():
return this.buildConditions([condition_1.Condition.Great], columns);
default:
if (columns[1]) {
return "".concat(columns[0], " ").concat(this.builderConditions(conditions), " ").concat(columns[1]).trim();
}
return "".concat(columns[0], " ").concat(this.builderConditions(conditions)).trim();
}
};
WhereBaseBuilder.prototype.builderConditions = function (conditions) {
return conditions.join(" ");
};
WhereBaseBuilder.prototype.checkWhere = function () {
this._where += this._where.length ? " ".concat(this._pendingAndOr, " ") : "";
this._pendingAndOr = WhereBaseBuilder.AND;
};
WhereBaseBuilder.prototype.compileScope = function (compiled) {
this.buildWhereColumn(void 0, {
column: compiled.where,
params: compiled.params
}, void 0);
};
WhereBaseBuilder.AND = "AND";
WhereBaseBuilder.OR = "OR";
return WhereBaseBuilder;
}());
exports.WhereBaseBuilder = WhereBaseBuilder;