@blazedpath/commons 0.2.2 → 0.3.1

package/blz-rds/index.js

@@ -1,744 +0,0 @@
-const BlzRdsHelper = require('./blz-rds-helper');
-const BlzRdsExecutor = require('./blz-rds-executor');
-const SqlString = require('sqlstring');
-
-
-const rdsEscapeId = function(identifier) {
-    return SqlString.escapeId(identifier)
-}
-
-const rdsEscape = function(value) {
-    return SqlString.escape(value)
-}
-
-const getColumnPrimaryKey = function (rdsTable) {
-    for (let i = 0; i < rdsTable.columns.length; i++) {
-        let column = rdsTable.columns[i];
-        if (column.primaryKey)
-            return column;
-    }
-    return null;
-};
-
-const getColumnNameByAlias = function (rdsTable, alias) {
-    for (let i = 0; i < rdsTable.columns.length; i++) {
-        let column = rdsTable.columns[i];
-        if (column.alias === alias)
-            return column.name;
-    }
-    return null;
-};
-
-const setValue = function (obj, codePath, value) {
-    let posPoint = codePath.indexOf('.');
-    if (posPoint === -1)
-        obj[codePath] = value;
-    else {
-        let firstPart = codePath.substring(0, posPoint);
-        let lastParts = codePath.substring(posPoint + 1, codePath.length);
-        if (obj[firstPart] === undefined)
-            obj[firstPart] = {};
-        return setValue(obj[firstPart], lastParts, value);
-    }
-};
-
-const rdsSelect = async function (callContext, connection, rdsSelectConfig, fnSelector) {
-    let rdsTable = connection.rdsElements[rdsSelectConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: true };
-    embeddeds[0] = embedded;
-    if (rdsSelectConfig.fields)
-        for (let i = 0; i < rdsSelectConfig.fields.length; i++) {
-            let field = rdsSelectConfig.fields[i];
-            BlzRdsHelper.prebuild(connection, field, embeddeds);
-        }
-    if (rdsSelectConfig.where)
-        BlzRdsHelper.prebuild(connection, rdsSelectConfig.where, embeddeds);
-    if (rdsSelectConfig.orders)
-        for (let i = 0; i < rdsSelectConfig.orders.length; i++) {
-            let order = rdsSelectConfig.orders[i];
-            BlzRdsHelper.prebuild(connection, order, embeddeds);
-        }
-    let sql = '';
-    let values = [];
-    let types = [];
-    let fieldSentencesAggregates = [];
-    let fieldSentencesNoAggregates = [];
-    for (let i = 0; i < rdsSelectConfig.fields.length; i++) {
-        let field = rdsSelectConfig.fields[i];
-        let fieldSentence = BlzRdsHelper.getSql(field, connection.provider.syntaxis, values);
-        if (field.command === 'avg' || field.command === 'count' || field.command === 'countDistinct' || field.command === 'max' || field.command === 'min' || field.command === 'sum')
-            fieldSentencesAggregates.push(fieldSentence);
-        else
-            fieldSentencesNoAggregates.push(fieldSentence);
-        sql += fieldSentence + ' C' + i + ', ';
-        types.push(BlzRdsHelper.getType(field));
-    }
-    sql = sql.slice(0, -2);
-    sql += ' FROM ' + rdsTable.tableName + ' T0';
-    for (let i = 0; i < embedded.rdsJoins.length; i++) {
-        let rdsJoin = embedded.rdsJoins[i];
-        sql += ' ' + rdsJoin.sql;
-    }
-    if (rdsSelectConfig.where) {
-        let sqlWhere = BlzRdsHelper.getSql(rdsSelectConfig.where, connection.provider.syntaxis, values, true);
-        if (sqlWhere)
-            sql += ' WHERE ' + sqlWhere;
-    }
-    if (fieldSentencesAggregates.length > 0 && fieldSentencesNoAggregates.length > 0) {
-        sql += ' GROUP BY ';
-        for (let i = 0; i < fieldSentencesNoAggregates.length; i++) {
-            sql += fieldSentencesNoAggregates[i] + ', ';
-        }
-        sql = sql.slice(0, -2);
-    }
-    if (rdsSelectConfig.orders && rdsSelectConfig.orders.length > 0) {
-        let sqlsOrders = [];
-        for (let i = 0; i < rdsSelectConfig.orders.length; i++) {
-            let order = rdsSelectConfig.orders[i];
-            sqlsOrders.push(BlzRdsHelper.getSql(order, connection.provider.syntaxis, values));
-        }
-        sql += ' ORDER BY ' + sqlsOrders.join(', ');
-    }
-    if (rdsSelectConfig.offset !== null && rdsSelectConfig.offset !== undefined && rdsSelectConfig.limit !== null && rdsSelectConfig.limit !== undefined)
-        sql = BlzRdsHelper.stringFormat(rdsSelectConfig.offset === 0 ? connection.provider.syntaxis.selectWithPaging1 : connection.provider.syntaxis.selectWithPagingN, sql, rdsSelectConfig.offset, rdsSelectConfig.offset + rdsSelectConfig.limit, rdsSelectConfig.limit);
-    else
-        sql = 'SELECT ' + sql;
-    let parameters = [];
-    for (let i = 0; i < values.length; i++) {
-        let value = values[i];
-        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in' });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, { query: true }, types, fnSelector);
-    return result.data;
-};
-
-const rdsSelectReader = function (connection, rdsSelectReaderConfig) {
-    return {
-        _blz_reader: true,
-        connection: connection,
-        rdsSelectReaderConfig: rdsSelectReaderConfig,
-        rdsTable: connection.rdsElements[rdsSelectReaderConfig.rdsTableName],
-        read: async function (callContext, codePaths, fnSelection) {
-            let rdsSelectConfig = JSON.parse(JSON.stringify(this.rdsSelectReaderConfig));
-            rdsSelectConfig.fields = [];
-            for (let i = 0; i < codePaths.length; i++) {
-                let codePath = codePaths[i];
-                if (BlzRdsHelper.isValidCodePath(this.connection, this.rdsTable, codePath)) {
-                    rdsSelectConfig.fields.push({
-                        command: 'columnRef',
-                        columnRef: { codePath: codePath, embeddedIndex: 0 }
-                    });
-                }
-                else {
-                    rdsSelectConfig.fields.push({
-                        command: 'null'
-                    });
-                }
-            }
-            return await rdsSelect(
-                callContext,
-                this.connection,
-                rdsSelectConfig,
-                async function (row) {
-                    let obj = {};
-                    for (let i = 0; i < codePaths.length; i++) {
-                        let codePath = codePaths[i];
-                        setValue(obj, codePath, row[i]);
-                    }
-                    return await fnSelection(obj);
-                });
-        }
-    };
-};
-
-const rdsSelectOne = async function (callContext, connection, rdsSelectOneConfig, fnSelector) {
-    let rdsTable = connection.rdsElements[rdsSelectOneConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: true };
-    embeddeds[0] = embedded;
-    if (rdsSelectOneConfig.fields)
-        for (let i = 0; i < rdsSelectOneConfig.fields.length; i++) {
-            let field = rdsSelectOneConfig.fields[i];
-            BlzRdsHelper.prebuild(connection, field, embeddeds);
-        }
-    if (rdsSelectOneConfig.where)
-        BlzRdsHelper.prebuild(connection, rdsSelectOneConfig.where, embeddeds);
-    let sql = '';
-    let values = [];
-    let types = [];
-    sql += 'SELECT ';
-    let fieldSentencesAggregates = [];
-    let fieldSentencesNoAggregates = [];
-    for (let i = 0; i < rdsSelectOneConfig.fields.length; i++) {
-        let field = rdsSelectOneConfig.fields[i];
-        let fieldSentence = BlzRdsHelper.getSql(field, connection.provider.syntaxis, values);
-        if (field.command === 'avg' || field.command === 'count' || field.command === 'countDistinct' || field.command === 'max' || field.command === 'min' || field.command === 'sum')
-            fieldSentencesAggregates.push(fieldSentence);
-        else
-            fieldSentencesNoAggregates.push(fieldSentence);
-        sql += fieldSentence + ' C' + i + ', ';
-        types.push(BlzRdsHelper.getType(field));
-    }
-    sql = sql.slice(0, -2);
-    sql += ' FROM ' + rdsTable.tableName + ' T0';
-    for (let i = 0; i < embedded.rdsJoins.length; i++) {
-        let rdsJoin = embedded.rdsJoins[i];
-        sql += ' ' + rdsJoin.sql;
-    }
-    if (rdsSelectOneConfig.where) {
-        let sqlWhere = BlzRdsHelper.getSql(rdsSelectOneConfig.where, connection.provider.syntaxis, values, true);
-        if (sqlWhere)
-            sql += ' WHERE ' + sqlWhere;
-    }
-    if (fieldSentencesAggregates.length > 0 && fieldSentencesNoAggregates.length > 0) {
-        sql += ' GROUP BY ';
-        for (let i = 0; i < fieldSentencesNoAggregates.length; i++) {
-            sql += fieldSentencesNoAggregates[i] + ', ';
-        }
-        sql = sql.slice(0, -2);
-    }
-    let parameters = [];
-    for (let i = 0; i < values.length; i++) {
-        let value = values[i];
-        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in' });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, { queryOne: true }, types, fnSelector);
-    return result.data;
-};
-
-const rdsSelectOneReader = function (connection, rdsSelectOneReaderConfig) {
-    return {
-        _blz_reader: true,
-        connection: connection,
-        rdsSelectOneReaderConfig: rdsSelectOneReaderConfig,
-        rdsTable: connection.rdsElements[rdsSelectOneReaderConfig.rdsTableName],
-        read: async function (callContext, codePaths, fnSelection) {
-            let rdsSelectOneConfig = JSON.parse(JSON.stringify(this.rdsSelectOneReaderConfig));
-            rdsSelectOneConfig.fields = [];
-            for (let i = 0; i < codePaths.length; i++) {
-                let codePath = codePaths[i];
-                if (BlzRdsHelper.isValidCodePath(this.connection, this.rdsTable, codePath)) {
-                    rdsSelectOneConfig.fields.push({
-                        command: 'columnRef',
-                        columnRef: { codePath: codePath, embeddedIndex: 0 }
-                    });
-                }
-                else {
-                    rdsSelectOneConfig.fields.push({
-                        command: 'null',
-                        columnRef: { codePath: codePath, embeddedIndex: 0 }
-                    });
-                }
-            }
-            return await rdsSelectOne(
-                callContext,
-                this.connection,
-                rdsSelectOneConfig,
-                async function (row) {
-                    let obj = {};
-                    for (let i = 0; i < codePaths.length; i++) {
-                        let codePath = codePaths[i];
-                        setValue(obj, codePath, row[i]);
-                    }
-                    return await fnSelection(obj);
-                });
-        }
-    };
-};
-
-const rdsExists = async function (callContext, connection, rdsExistsConfig) {
-    let rdsTable = connection.rdsElements[rdsExistsConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: true };
-    embeddeds[0] = embedded;
-    if (rdsExistsConfig.where)
-        BlzRdsHelper.prebuild(connection, rdsExistsConfig.where, embeddeds);
-    let sql = '';
-    let values = [];
-    sql += 'EXISTS(SELECT 1 FROM ' + rdsTable.tableName + ' T0';
-    for (let i = 0; i < embedded.rdsJoins.length; i++) {
-        let rdsJoin = embedded.rdsJoins[i];
-        sql += ' ' + rdsJoin.sql;
-    }
-    if (rdsExistsConfig.where) {
-        let sqlWhere = BlzRdsHelper.getSql(rdsExistsConfig.where, connection.provider.syntaxis, values, true);
-        if (sqlWhere)
-            sql += ' WHERE ' + sqlWhere;
-    }
-    sql += ')';
-    sql = BlzRdsHelper.stringFormat(connection.provider.syntaxis.selectExists, sql);
-    let parameters = [];
-    for (let i = 0; i < values.length; i++) {
-        let value = values[i];
-        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in' });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, { queryOne: true }, ['boolean'], function(ctx) { return ctx[0]; });
-    return result.data;
-};
-
-const rdsInsert = async function (callContext, connection, rdsInsertConfig) {
-    let rdsTable = connection.rdsElements[rdsInsertConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: false };
-    embeddeds[0] = embedded;
-    if (rdsInsertConfig.sets)
-        for (let i = 0; i < rdsInsertConfig.sets.length; i++) {
-            let set = rdsInsertConfig.sets[i];
-            BlzRdsHelper.prebuild(connection, set.value, embeddeds);
-        }
-    let sql = '';
-    let values = [];
-    let setsFields = [];
-    let setsValues = [];
-    const columns = [];
-    for (let i = 0; i < rdsInsertConfig.sets.length; i++) {
-        let set = rdsInsertConfig.sets[i];
-        setsFields.push(getColumnNameByAlias(rdsTable, set.columnAlias));
-        setsValues.push(BlzRdsHelper.getSql(set.value, connection.provider.syntaxis, values));
-        columns.push(rdsTable.columns.find(p=> p.alias === set.columnAlias))  
-    }
-    let autoincrementalData = null;
-    if (rdsTable.autoincrementalPrimaryKey) {
-        if (connection.provider.syntaxis.insertAutoIncremental.indexOf('%2$s') !== -1 && (rdsTable.sequenceName === '' || rdsTable.sequenceName === null || rdsTable.sequenceName === undefined)) {
-            let err = new Error();
-            err.code = 'RdsError';
-            err.message = 'Table ' + rdsTable.tableName + ' does not have sequence defined. Sequence definition is mandatory in the current db provider.';
-            throw err;
-        }
-        autoincrementalData = {
-            tableName: rdsTable.tableName,
-            sequenceName: rdsTable.sequenceName,
-            pkColumnName: getColumnPrimaryKey(rdsTable).name
-        };
-        sql += BlzRdsHelper.stringFormat(connection.provider.syntaxis.insertAutoIncremental, autoincrementalData.tableName, autoincrementalData.sequenceName, autoincrementalData.pkColumnName, setsFields.join(', '), setsValues.join(', '));
-    }
-    else {
-        sql += 'INSERT INTO ' + rdsTable.tableName + ' (' + setsFields.join(', ') + ') VALUES (' + setsValues.join(', ') + ')';
-    }
-    let parameters = [];
-    for (let i = 0; i < values.length; i++) {
-        let value = values[i];
-        let columnInfo = await findByAlias(connection.rdsElements[rdsInsertConfig.rdsTableName].columns, rdsInsertConfig.sets[i].columnAlias);
-        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in', columnInfo: columnInfo });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, { autoincrementalData, columns });
-    return result.id !== undefined ? result.id : null
-};
-const findByAlias = async function (array, alias) {
-    return array.find(obj => obj.alias === alias);
-}
-
-const rdsInsertConditional = async function (callContext, connection, rdsInsertConfig) {
-    let rdsTable = connection.rdsElements[rdsInsertConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: false };
-    embeddeds[0] = embedded;
-    if (rdsInsertConfig.sets)
-        for (let i = 0; i < rdsInsertConfig.sets.length; i++) {
-            let set = rdsInsertConfig.sets[i];
-            BlzRdsHelper.prebuild(connection, set.value, embeddeds);
-        }
-    if (rdsInsertConfig.where)
-        BlzRdsHelper.prebuild(connection, rdsInsertConfig.where, embeddeds);    
-    let sql = '';
-    let values = [];
-    let setsFields = [];
-    let setsValues = [];
-    for (let i = 0; i < rdsInsertConfig.sets.length; i++) {
-        let set = rdsInsertConfig.sets[i];
-        setsFields.push(getColumnNameByAlias(rdsTable, set.columnAlias));
-        setsValues.push(BlzRdsHelper.getSql(set.value, connection.provider.syntaxis, values));
-    }
-    if (!rdsInsertConfig.where) {
-        let err = new Error();
-        err.code = 'RdsError';
-        err.message = 'Table ' + rdsTable.tableName + ' does not have WHERE defined.';
-        throw err;
-    }
-    const sqlWhere = BlzRdsHelper.getSql(rdsInsertConfig.where, connection.provider.syntaxis, values, true);
-    if (!sqlWhere) {
-        let err = new Error();
-        err.code = 'RdsError';
-        err.message = 'Table ' + rdsTable.tableName + ' does not have WHERE defined.';
-        throw err;
-    }   
-    let autoincrementalData = null;
-    if (rdsTable.autoincrementalPrimaryKey) {
-        if (connection.provider.syntaxis.insertConditionalAutoIncremental.indexOf('%2$s') !== -1 && (rdsTable.sequenceName === '' || rdsTable.sequenceName === null || rdsTable.sequenceName === undefined)) {
-            let err = new Error();
-            err.code = 'RdsError';
-            err.message = 'Table ' + rdsTable.tableName + ' does not have sequence defined. Sequence definition is mandatory in the current db provider.';
-            throw err;
-        }
-        autoincrementalData = {
-            tableName: rdsTable.tableName,
-            sequenceName: rdsTable.sequenceName,
-            pkColumnName: getColumnPrimaryKey(rdsTable).name
-        };
-        sql += BlzRdsHelper.stringFormat(connection.provider.syntaxis.insertConditionalAutoIncremental, autoincrementalData.tableName, autoincrementalData.sequenceName, autoincrementalData.pkColumnName, setsFields.join(', '), setsValues.join(', '), sqlWhere);
-    }
-    else {
-        sql += BlzRdsHelper.stringFormat(connection.provider.syntaxis.insertConditional, rdsTable.tableName, "", "", setsFields.join(', '), setsValues.join(', '), sqlWhere);
-    }
-    let parameters = [];
-    for (let i = 0; i < values.length; i++) {
-        let value = values[i];
-        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in' });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, { autoincrementalData: autoincrementalData });
-    return result.id !== undefined ? result.id : null
-};
-
-const rdsBulkInsert = async function (callContext, connection, rdsInsertConfig) {    
-    let rdsTable = connection.rdsElements[rdsInsertConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: false };
-    embeddeds[0] = embedded;
-    if (!rdsInsertConfig.list || rdsInsertConfig.list.length === 0) {
-        return []
-    }
-    let values = [];
-    let setsFields = [];
-    const columns = []
-    for (let i = 0; i < rdsInsertConfig.sets.length; i++) {
-        let field = rdsInsertConfig.sets[i];
-        setsFields.push(getColumnNameByAlias(rdsTable, field.columnAlias))        
-        columns.push(rdsTable.columns.find(p=> p.alias === field.columnAlias))        
-    }
-    for (let i = 0; i < rdsInsertConfig.list.length; i++) {
-        let row = rdsInsertConfig.list[i];
-        values.push(row);
-    }
-    let autoincrementalData = null;
-    if (rdsTable.autoincrementalPrimaryKey) {
-        if (connection.provider.syntaxis.insertAutoIncremental.indexOf('%2$s') !== -1 && (rdsTable.sequenceName === '' || rdsTable.sequenceName === null || rdsTable.sequenceName === undefined)) {
-            let err = new Error();
-            err.code = 'RdsError';
-            err.message = 'Table ' + rdsTable.tableName + ' does not have sequence defined. Sequence definition is mandatory in the current db provider.';
-            throw err;
-        }
-        const pkColumn = getColumnPrimaryKey(rdsTable)
-        autoincrementalData = {
-            tableName: rdsTable.tableName,
-            sequenceName: rdsTable.sequenceName,
-            pkColumnName: pkColumn.name,
-            pkColumnAlias: pkColumn.alias,
-            pkColumnType: pkColumn.type
-        };
-    }
-    const sql = 'INSERT INTO ' + rdsTable.tableName + ' (' + setsFields.join(', ') + ') VALUES ';
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, values, { bulkInsert:true, autoincrementalData: autoincrementalData, columns , setsFields, rdsTable });
-    return result.ids !== undefined ? result.ids : null
-};
-
-const rdsBulkMerge = async function (callContext, connection, rdsMergeConfig) {    
-    let rdsTable = connection.rdsElements[rdsMergeConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: false };
-    embeddeds[0] = embedded;
-
-    if (!rdsMergeConfig.sets || rdsMergeConfig.sets.length === 0) {
-        return []
-    }    
-    for (let i = 0; i < rdsMergeConfig.sets.length; i++) {
-        let set = rdsMergeConfig.sets[i];
-        for (let j = 0; j < set.length; j++) {                
-            BlzRdsHelper.prebuild(connection, set[j].value, embeddeds);
-        }
-    }
-    let values = [];
-    let setsFields = [];
-    const columns = []
-    const firstRow = rdsMergeConfig.sets[0]
-    if (!rdsMergeConfig.fields) {
-        let err = new Error();
-        err.code = 'RdsError';
-        err.message = 'Merge sentence does not have fields defined.';
-        throw err;
-    }
-    for (let i = 0; i < firstRow.length; i++) {
-        let field = firstRow[i];
-        setsFields.push(getColumnNameByAlias(rdsTable, field.columnAlias))        
-        columns.push(rdsTable.columns.find(p=> p.alias === field.columnAlias))        
-    }
-    for (let i = 0; i < rdsMergeConfig.sets.length; i++) {
-        let set = rdsMergeConfig.sets[i];
-        let row = [];
-        for (let j = 0; j < set.length; j++) {              
-            BlzRdsHelper.getSql(set[j].value, connection.provider.syntaxis, row)
-        }
-        values.push(row);
-    }
-    let autoincrementalData = null;
-    if (rdsTable.autoincrementalPrimaryKey) {
-        if (connection.provider.syntaxis.insertAutoIncremental.indexOf('%2$s') !== -1 && (rdsTable.sequenceName === '' || rdsTable.sequenceName === null || rdsTable.sequenceName === undefined)) {
-            let err = new Error();
-            err.code = 'RdsError';
-            err.message = 'Table ' + rdsTable.tableName + ' does not have sequence defined. Sequence definition is mandatory in the current db provider.';
-            throw err;
-        }
-        const pkColumn = getColumnPrimaryKey(rdsTable)
-        autoincrementalData = {
-            tableName: rdsTable.tableName,
-            sequenceName: rdsTable.sequenceName,
-            pkColumnName: pkColumn.name,
-            pkColumnAlias: pkColumn.alias,
-            pkColumnType: pkColumn.type
-        };
-    }
-    if (!rdsMergeConfig.fields || !rdsMergeConfig.fields.length || rdsMergeConfig.fields.length === 0) {
-        let err = new Error();
-        err.code = 'RdsError';
-        err.message = 'Merge sentence does not have merge fields defined.';
-        throw err;
-    }
-    const mergeFields = []
-    for(const field of rdsMergeConfig.fields) {
-        if (!field || !field.columnRef || !field.columnRef.codePath) {
-            let err = new Error();
-            err.code = 'RdsError';
-            err.message = 'Merge sentence does not have merge fields defined.';
-            throw err;
-        }
-        const fieldName = field.columnRef.codePath
-        const column = rdsTable.columns.find((p) => p.alias === fieldName)
-        if (!column) {
-            let err = new Error();
-            err.code = 'RdsError';
-            err.message = 'Merge sentence does not have merge fields defined.';
-            throw err;
-        }
-        if( !rdsTable.uniqueKeys || rdsTable.uniqueKeys.length === 0 || rdsTable.uniqueKeys.filter(p =>   p.columnsNames !== undefined && p.columnsNames.find(c => c === column.name)).length === 0 ) {
-            if (rdsTable.columns.filter(p => p.primaryKey && p.name === column.name).length === 0) { 
-                let err = new Error();
-                err.code = 'RdsError';
-                err.message = 'The field selected to determine the merge must be defined as unique key or primary key';
-                throw err;
-            }
-        }
-    }
-    const sql = '';
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, values, { bulkMerge:true, mergeFields:mergeFields, autoincrementalData: autoincrementalData, columns , setsFields, rdsTable });
-    return result.affectedRows
-};
-
-const rdsInsertWriter = function (connection, rdsInsertWriterConfig) {
-    return {
-        isWriter: true,
-        connection: connection,
-        rdsInsertWriterConfig: rdsInsertWriterConfig,
-        write: async function (callContext, obj) {
-            let rdsTable = this.connection.rdsElements[this.rdsInsertWriterConfig.rdsTableName];
-            let pkAliases = [];
-            for (let i = 0; i < rdsTable.columns.length; i++) {
-                let column = rdsTable.columns[i];
-                if (column.primaryKey)
-                    pkAliases.push(column.alias);
-            }
-            let rdsInsertConfig = JSON.parse(JSON.stringify(this.rdsInsertWriterConfig));
-            rdsInsertConfig.sets = [];
-            for (var key in obj) {
-                var value = obj[key];
-                if (!(rdsTable.autoincrementalPrimaryKey && pkAliases.indexOf(key) !== -1))
-                    rdsInsertConfig.sets.push({ columnAlias: key, value: { command: 'parameter', parameterValue: value } });
-            }
-            return await rdsInsert(callContext, this.connection, rdsInsertConfig);
-        }
-    };
-};
-
-const rdsUpdate = async function (callContext, connection, rdsUpdateConfig) {
-    let rdsTable = connection.rdsElements[rdsUpdateConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: false };
-    embeddeds[0] = embedded;
-    if (rdsUpdateConfig.sets)
-        for (let i = 0; i < rdsUpdateConfig.sets.length; i++) {
-            let set = rdsUpdateConfig.sets[i];
-            BlzRdsHelper.prebuild(connection, set.value, embeddeds);
-        }
-    if (rdsUpdateConfig.where)
-        BlzRdsHelper.prebuild(connection, rdsUpdateConfig.where, embeddeds);
-    let sql = '';
-    let values = [];
-    sql += 'UPDATE ' + rdsTable.tableName;
-    let setsFieldsValues = [];
-    for (let i = 0; i < rdsUpdateConfig.sets.length; i++) {
-        let set = rdsUpdateConfig.sets[i];
-        setsFieldsValues.push(getColumnNameByAlias(rdsTable, set.columnAlias) + ' = ' + BlzRdsHelper.getSql(set.value, connection.provider.syntaxis, values));
-    }
-    sql += ' SET ' + setsFieldsValues.join(', ');
-    if (rdsUpdateConfig.where) {
-        let sqlWhere = BlzRdsHelper.getSql(rdsUpdateConfig.where, connection.provider.syntaxis, values, true);
-        if (sqlWhere)
-            sql += ' WHERE ' + sqlWhere;
-    }
-    let parameters = [];
-    for (let i = 0; i < values.length; i++) {
-        let value = values[i];
-        let columnInfo = null;
-        if (rdsUpdateConfig.sets[i])
-            columnInfo = await findByAlias(connection.rdsElements[rdsUpdateConfig.rdsTableName].columns, rdsUpdateConfig.sets[i].columnAlias);
-        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in', columnInfo: columnInfo  });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, null);
-    return result.rowsAffected;
-};
-
-const rdsUpdateWriter = function (connection, rdsUpdateWriterConfig) {
-    return {
-        isWriter: true,
-        connection: connection,
-        rdsUpdateWriterConfig: rdsUpdateWriterConfig,
-        write: async function (callContext, obj) {
-            let rdsTable = this.connection.rdsElements[this.rdsUpdateWriterConfig.rdsTableName];
-            let pkAliases = [];
-            for (let i = 0; i < rdsTable.columns.length; i++) {
-                let column = rdsTable.columns[i];
-                if (column.primaryKey)
-                    pkAliases.push(column.alias);
-            }
-            let rdsUpdateConfig = JSON.parse(JSON.stringify(this.rdsUpdateWriterConfig));
-            rdsUpdateConfig.sets = [];
-            let whereChildren = [];
-            for (var key in obj) {
-                var value = obj[key];
-                if (pkAliases.indexOf(key) === -1)
-                    rdsUpdateConfig.sets.push({ columnAlias: key, value: { command: 'parameter', parameterValue: value } });
-                else
-                    whereChildren.push({ command: 'equals', children: [{ command: 'columnRef', columnRef: { codePath: key, embeddedIndex: 0 }}, { command: 'parameter', parameterValue: value }] });
-            }
-            if (whereChildren.length > 0)
-                rdsUpdateConfig.where = { command: 'and', children: whereChildren };
-            return await rdsUpdate(callContext, this.connection, rdsUpdateConfig);
-        }
-    };
-};
-
-const rdsDelete = async function (callContext, connection, rdsDeleteConfig) {
-    let rdsTable = connection.rdsElements[rdsDeleteConfig.rdsTableName];
-    let embeddeds = {};
-    let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: false };
-    embeddeds[0] = embedded;
-    if (rdsDeleteConfig.where)
-        BlzRdsHelper.prebuild(connection, rdsDeleteConfig.where, embeddeds);
-    let sql = '';
-    let values = [];
-    sql += 'DELETE FROM ' + rdsTable.tableName;
-    if (rdsDeleteConfig.where) {
-        let sqlWhere = BlzRdsHelper.getSql(rdsDeleteConfig.where, connection.provider.syntaxis, values, true);
-        if (sqlWhere)
-            sql += ' WHERE ' + sqlWhere;
-    }
-    let parameters = [];
-    for (let i = 0; i < values.length; i++) {
-        let value = values[i];
-        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in' });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, null);
-    return result.rowsAffected;
-};
-
-const rdsExecuteStoredProcedure = async function (callContext, connection, rdsStoredProcedureName, parameters) {
-    let rdsStoredProcedure = connection.rdsElements[rdsStoredProcedureName];
-    let spParameterNames = [];
-    let spParameters = [];
-    if (rdsStoredProcedure.parameters)
-        for (let i = 0; i < rdsStoredProcedure.parameters.length; i++) {
-            let rdsStoredProcedureParameter = rdsStoredProcedure.parameters[i];
-            let spParameter = {
-                name: rdsStoredProcedureParameter.name,
-                type: rdsStoredProcedureParameter.type,
-                direction: rdsStoredProcedureParameter.direction,
-                isExplicitParameter: rdsStoredProcedureParameter.isExplicitParameter,
-                isResultSet: rdsStoredProcedureParameter.isResultSet,
-                attributes: rdsStoredProcedureParameter.attributes,
-                dbTypes: rdsStoredProcedureParameter.dbTypes
-            };
-            if (!rdsStoredProcedureParameter.isResultSet ||
-                (rdsStoredProcedureParameter.isResultSet && (connection.provider.syntaxis.storedProcedureResultSet === 'explicit' || (connection.provider.syntaxis.storedProcedureResultSet !== 'implicit' && rdsStoredProcedureParameter.isExplicitParameter)))) {
-                spParameterNames.push(BlzRdsHelper.stringFormat(connection.provider.syntaxis.core.parameter, rdsStoredProcedureParameter.name));
-                spParameter.isExplicitParameter = true;
-            }
-            else {
-                spParameter.isExplicitParameter = false;
-            }
-            if (parameters)
-                spParameter.value = parameters[rdsStoredProcedureParameter.name];
-            spParameters.push(spParameter);
-        }
-    let sql = BlzRdsHelper.stringFormat(connection.provider.syntaxis.executeStoredProcedure, rdsStoredProcedure.storedProcedureName, spParameterNames.join(', '));
-    return (await BlzRdsExecutor.execute(callContext, connection, sql, spParameters, null)).outParameters;
-};
-
-const rdsExecuteQuery = async function (callContext, connection, sql, parameters, resultTypes) {
-    let sqlParameters = [];
-    for (let name in parameters) {
-        sql = sql.split('@' + name).join(BlzRdsHelper.stringFormat(connection.provider.syntaxis.core.parameter, name));
-        sqlParameters.push({ name: name, value: parameters[name], direction: 'in' });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, sqlParameters, { query: true }, resultTypes, function (row) { return row; });
-    return result.data;
-};
-
-const rdsExecuteNonQuery = async function (callContext, connection, sql, parameters) {
-    let sqlParameters = [];
-    for (let name in parameters) {
-        sql = sql.split('@' + name).join(BlzRdsHelper.stringFormat(connection.provider.syntaxis.core.parameter, name));
-        sqlParameters.push({ name: name, value: parameters[name], direction: 'in' });
-    }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, sqlParameters, null);
-    return result.rowsAffected;
-};
-
-const rdsConnectionHealthCheck = async function (connection, callContext) {
-    let sql = '';
-    let sqlParameters = [];
-    switch (connection.providerName) {
-        case 'Postgres': {
-            sql = 'SELECT NOW();'
-            break;
-        }
-        case 'Oracle': {
-            sql = 'SELECT SYSDATE FROM DUAL'
-            break;
-        }
-        default:{
-            return { error: "Provider not yet implemented"}
-        }
-    }
-    // If this sql query was able to return a date, connection works
-    try {
-        let result = await BlzRdsExecutor.execute(callContext, connection, sql, sqlParameters, { query: true }, null, function (row) { return row; });
-        if (result && result.data && result.data.length === 1) {
-            return { status: "ok", message: `Connection works, server datetime: ${JSON.stringify(result.data)}` }
-        } else {
-            return { status: "error", error: `Unable to obtain date from database ${JSON.stringify(result)}` }
-        } 
-    } catch (error) {
-        return { status: "error", error: JSON.stringify(error) }
-    }
-};
-
-module.exports = {
-    rdsSelect,
-    rdsSelectReader,
-    rdsSelectOne,
-    rdsSelectOneReader,
-    rdsExists,
-    rdsInsert,
-    rdsInsertConditional,
-    rdsBulkInsert,
-    rdsBulkMerge,
-    rdsInsertWriter,
-    rdsUpdate,
-    rdsUpdateWriter,
-    rdsDelete,
-    rdsExecuteStoredProcedure,
-    rdsExecuteQuery,
-    rdsExecuteNonQuery,
-    rdsConnectionHealthCheck,
-    rdsEscape,
-    rdsEscapeId
-}