Function ExecuteQuery

src/db/Query.js:21–66

(type, dbId, query, values, callback, cache)

});

async function ExecuteQuery(type, dbId, query, values, callback, cache) {
    const start = performance.now();
    let connection = null;
    try {
        if (global.interceptor) {
            let resourceName = GetInvokingResource();
            const resultMiddleware = await QueryInterceptor({ resourceName, type, dbId, query, values, callback, cache });
            if (resultMiddleware === null) return callback ? callback(null) : null;
            ({ resourceName, type, dbId, query, values, callback, cache } = resultMiddleware);
        }

        connection = await GetConnection(dbId);

        if (values) {
            if(typeof(values) === "string")
                values = [values];
        } else {
            values = null;
        }
        values = ParseNilArgs(query, values)

        if (query.includes("@")) {
            query = ReplaceNamedParams(query, values)
            values = null;
        }
        const [rows] = (type == "Raw" || type == "Scalar" || type == "Single" || type == "Update" || type == "Insert" || type == "Query") 
            ? await connection.query(query, values) : await connection.execute(query, values);
        const end = performance.now();
        const time = (end - start).toFixed(3);

        if (time >= Config.SlowQueryWarn) {
            Log(LogTypes.Warning, `Slow query detected: ${query} - ${time}ms`)
        }

        let result = ParseResponse(type, rows);
        try {
            return callback ? callback(result) : result;
        } catch(err) {
            return result;
        }
    } catch (err) {
        ParseError(`Error while executing query: ${err} , query: ${query}, values: ${values}`, null, true);
    } finally {
        ReleaseConnection(dbId, connection)
    }
}

async function ExecuteTransaction(dbId, queries, params, callback) {
    const connection = await GetConnection(dbId);