ddl-manager/dist/parser/SelectParser.js

store postgres procedures and triggers in files

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SelectParser = void 0;
const ExpressionParser_1 = require("./ExpressionParser");
const ast_1 = require("../ast");
const utils_1 = require("./utils");
class SelectParser {
    constructor() {
        this.expressionParser = new ExpressionParser_1.ExpressionParser();
    }
    parse(selectNode) {
        let select = new ast_1.Select();
        select = this.parseFromItems(selectNode, select);
        select = this.parseColumns(selectNode, select);
        select = this.parseWhere(selectNode, select);
        select = this.parseOrderBy(selectNode, select);
        select = this.parseLimit(selectNode, select);
        return select;
    }
    parseFromItems(selectNode, select) {
        const fromItems = selectNode.row.from || [];
        fromItems.forEach(fromItem => {
            select = this.parseFromItem(select, fromItem);
        });
        return select;
    }
    parseFromItem(select, fromItem) {
        const alias = fromItem.row.as;
        const tableLink = fromItem.row.table;
        const tableRef = utils_1.parseFromTable(tableLink, alias);
        let fromTable = new ast_1.From({ source: tableRef });
        const joinsSyntaxes = fromItem.row.joins || [];
        joinsSyntaxes.forEach(joinSyntax => {
            fromTable = this.parseJoin(fromTable, joinSyntax);
        });
        select = select.addFrom(fromTable);
        return select;
    }
    parseJoin(from, joinSyntax) {
        const fromItem = joinSyntax.row.from;
        const alias = fromItem.row.as;
        const tableLink = fromItem.row.table;
        const type = joinSyntax.row.type;
        const tableRef = utils_1.parseFromTable(tableLink, alias);
        const on = this.expressionParser.parse(joinSyntax.row.on);
        const join = new ast_1.Join(type, tableRef, on);
        from = from.addJoin(join);
        return from;
    }
    parseColumns(selectSyntax, select) {
        const columns = selectSyntax.row.select;
        for (const column of columns) {
            const name = column.row.as.toValue();
            const expressionSyntax = column.row.expression;
            const selectColumn = new ast_1.SelectColumn({
                name,
                expression: this.expressionParser.parse(expressionSyntax)
            });
            select = select.addColumn(selectColumn);
        }
        return select;
    }
    parseWhere(selectSyntax, select) {
        if (selectSyntax.row.where) {
            const whereExpression = this.expressionParser.parse(selectSyntax.row.where);
            select = select.addWhere(whereExpression);
        }
        return select;
    }
    parseOrderBy(selectSyntax, select) {
        const orderBySyntax = selectSyntax.row.orderBy || [];
        if (orderBySyntax.length) {
            const orderByItems = orderBySyntax.map(orderItemSyntax => {
                const type = (orderItemSyntax.row.vector || "asc")
                    .toLowerCase();
                const orderItem = new ast_1.OrderByItem({
                    type,
                    expression: this.expressionParser.parse(orderItemSyntax.row.expression),
                    nulls: orderItemSyntax.row.nulls
                });
                return orderItem;
            });
            const orderBy = new ast_1.OrderBy(orderByItems);
            select = select.addOrderBy(orderBy);
        }
        return select;
    }
    parseLimit(selectSyntax, select) {
        const limit = +(selectSyntax.row.limit || 0);
        if (limit > 0) {
            select = select.setLimit(limit);
        }
        return select;
    }
}
exports.SelectParser = SelectParser;
//# sourceMappingURL=SelectParser.js.map