Function parseSelectQuery

src/queryParser.js:4–136

(query)

Creating a Query Parser which can parse SQL `SELECT` Queries only.
// */
function parseSelectQuery(query) {
    try {

        // Trim the query to remove any leading/trailing whitespaces
        query = query.trim();

        // Initialize distinct flag
        let isDistinct = false; // Global DISTINCT, not within COUNT
        let isCountDistinct = false; // New flag for DISTINCT within COUNT
        let distinctFields = []; // Array to hold fields after DISTINCT within COUNT or APPROXIMATE_COUNT


        // Detect APPROXIMATE_COUNT
        let isApproximateCount = false;
        const approximateCountRegex = /APPROXIMATE_COUNT\((DISTINCT\s)?(.+?)\)/i;
        const approximateCountMatch = query.match(approximateCountRegex);
        if (approximateCountMatch) {
            isApproximateCount = true;
            // If DISTINCT is used within APPROXIMATE_COUNT, capture the fields
            if (approximateCountMatch[1]) {
                isCountDistinct = true;
                // distinctFields.push(approximateCountMatch[2].trim());
            }
            // Simplify further processing by normalizing to COUNT (adjust as necessary for your logic)
            query = query.replace(approximateCountRegex, `COUNT(${approximateCountMatch[1] || ''}${approximateCountMatch[2]})`);
        }

        // Check for DISTINCT keyword and update the query
        if (query.toUpperCase().includes('SELECT DISTINCT')) {
            isDistinct = true;
            query = query.replace('SELECT DISTINCT', 'SELECT');
        }

        // Updated regex to capture LIMIT clause and remove it for further processing
        const limitRegex = /\sLIMIT\s(\d+)/i;
        const limitMatch = query.match(limitRegex);

        let limit = null;
        if (limitMatch) {
            limit = parseInt(limitMatch[1], 10);
            query = query.replace(limitRegex, ''); // Remove LIMIT clause
        }

        // Process ORDER BY clause and remove it for further processing
        const orderByRegex = /\sORDER BY\s(.+)/i;
        const orderByMatch = query.match(orderByRegex);
        let orderByFields = null;
        if (orderByMatch) {
            orderByFields = orderByMatch[1].split(',').map(field => {
                const [fieldName, order] = field.trim().split(/\s+/);
                return { fieldName, order: order ? order.toUpperCase() : 'ASC' };
            });
            query = query.replace(orderByRegex, '');
        }

        // Process GROUP BY clause and remove it for further processing
        const groupByRegex = /\sGROUP BY\s(.+)/i;
        const groupByMatch = query.match(groupByRegex);