@blazedpath/commons 0.3.1 → 0.4.0

package/blz-rds/index.js

@@ -0,0 +1,744 @@
+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
+}