@blazedpath/commons 0.0.4

package/blz-rds-oracle/index.js

@@ -0,0 +1,540 @@
+const oracledb = require("oracledb");
+const _ = require("underscore");
+const { h3lp } = require('h3lp');
+// check blzBase location
+const Path = require('path');
+const Fs = require('fs-extra');
+const blzBaseSuite = Path.resolve(__dirname, '../../blz-core/sources-dual/index.js');
+let BlzBase = null;
+if (Fs.existsSync(blzBaseSuite)) {
+    BlzBase = require('../../blz-core/sources-dual/index.js');
+} else {
+    BlzBase = require('../blz-core/dual/index.js');
+}
+oracledb.fetchAsBuffer = [oracledb.BLOB];
+oracledb.fetchAsString = [oracledb.CLOB, oracledb.DATE, oracledb.NUMBER];
+
+let poolsByName = Object.create(null);
+
+const getPool = async function (connection) {
+    try {
+        if (!connection.name) {
+            throw new Error('You must provide a connnection name');
+        }
+        let key = connection.name;
+        let pool = poolsByName[key];
+        if (pool) {
+            return pool;
+        }
+
+        connection.connectString = connection.dataSource;
+        connection = _.omit(connection, "dataSource", "providerName");
+        connection.sessionCallback = makeInitSessionCallback({ schema: connection.schema })
+        // Enable instant client mode in Node.js
+        if (process.env.LD_LIBRARY_PATH){
+            oracledb.initOracleClient( { libDir: process.env.LD_LIBRARY_PATH, configDir: '', thin: false} );
+        }
+        pool = await oracledb.createPool(connection);
+        pool.connectionName = connection.name;
+        poolsByName[key] = pool;
+        return pool;
+    }
+    catch (err) {
+        throw new Error('Oracle cannot create pool for ' + connection.name + ': ' + err.message);
+    }
+};
+
+const makeInitSessionCallback = ({ schema } = {}) => (oraConnection, requestedTag, callbackFn) => {
+    const sessionSets = [
+        ['NLS_DATE_FORMAT', `'YYYY-MM-DD"T"hh24:mi:ss'`],
+        schema ? ['CURRENT_SCHEMA', `${schema}`] : undefined
+    ]
+
+    const sessionSetsString = sessionSets
+        .filter(Boolean)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(' ')
+
+    oraConnection.execute(`ALTER SESSION SET ${sessionSetsString}`, callbackFn)
+}
+
+const tryDatetime = function (value) {
+    let strType = toString.call(value);
+    if (strType === '[object Date]') {
+        return value;
+    }
+    else if (strType === '[object String]') {
+        let match = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+        if (match) {
+            const probableDate = new Date(value);
+            if (probableDate.toString() !== 'Invalid Date') {
+                return probableDate;  
+            }
+        }
+    }
+    return null;
+};
+const convertMilliseconds = function(strMilliseconds) {
+    if (strMilliseconds) {
+        if (strMilliseconds.length < 3)
+            strMilliseconds = strMilliseconds.padEnd(3, '0');
+        if (strMilliseconds.length > 3)
+            strMilliseconds = strMilliseconds.substr(0, 3);
+        return Number(strMilliseconds);
+    }
+    else
+        return 0;
+};
+
+const convertResultSetToArray = function (resultSet, results) {
+    return resultSet.getRow()
+        .then((row) => {
+            if (row) {
+                results.push(row);
+                return convertResultSetToArray(resultSet, results);
+            }
+            else
+                return resultSet.close()
+                    .then(() => {
+                        return results;
+                    });
+        })
+        .catch((err) => {
+            resultSet.close();
+            throw BlzBase.error('ErrorFetchingRowsForConnection', {}, err);
+        });
+}
+
+const getParameterType = function (type) {
+    switch (type) {
+        case 'string':
+            return oracledb.STRING
+        case 'integer':
+        case 'decimal':
+        case 'boolean':
+            return oracledb.NUMBER
+        case 'datetime':
+        case 'date':
+        case 'time':
+            return oracledb.DATE
+        case 'binary':
+            return oracledb.BUFFER
+        case 'CLOB':
+            return oracledb.CLOB;
+        case 'BLOB':
+            return oracledb.CLOB;
+        case 'VARCHAR':
+        case 'VARCHAR2':
+            return oracledb.STRING;
+        default:
+            return oracledb.STRING    
+    }
+}
+
+const getOraParameters = function (parameters,options) {
+    let oraParameters = {};
+    if (parameters)
+        for (let i = 0; i < parameters.length; i++) {
+            let parameter = parameters[i];            
+            let oraParameter = {};
+            // checks if i need to convert nodejs to oracle representation (bool -> 0,1) etcs
+            if (parameter.direction === 'in' || parameter.direction === 'in/out') {
+                if (parameter.value === undefined || parameter.value === null)
+                    oraParameter.val = null;
+                else if (parameter.value === true)
+                    oraParameter.val = 1;
+                else if (parameter.value === false)
+                    oraParameter.val = 0;
+                else {
+                    if (parameter.columnInfo && parameter.columnInfo.type === 'string') {
+                        oraParameter.val = parameter.value
+                    } else {
+                        let datetime = tryDatetime(parameter.value);
+                        if (datetime) {
+                            oraParameter.val = datetime;
+                            // Old Date management                                              
+                            // let tmp = datetime.toJSON();
+                            // if (tmp.length === 24)
+                            //     tmp = tmp.substring(0, 19);
+                            // oraParameter.val = tmp;
+                        }
+                        else {
+                            oraParameter.val = parameter.value;
+                        }
+                    }
+                }
+            }
+            // binds de in out
+            if (parameter.direction === 'in')
+                oraParameter.dir = oracledb.BIND_IN;
+            else if (parameter.direction === 'in/out')
+                oraParameter.dir = oracledb.BIND_INOUT;
+            else if (parameter.direction === 'out')
+                oraParameter.dir = oracledb.BIND_OUT;
+            // selects the parameter type
+            if (parameter.isResultSet)
+                oraParameter.type = oracledb.CURSOR;
+            else {
+                if (parameter.dbTypes){
+                    const oracleEntry = parameter.dbTypes.find(entry => entry.providerName === 'Oracle');
+                    parameter.dbType = getParameterType(oracleEntry.dbType);
+                } else if (parameter.type) {
+                    parameter.dbType = getParameterType(parameter.type);
+                }
+                else {
+                    parameter.dbType = inferDbTypeFromValue(parameter.value);
+                }
+                oraParameter.type = parameter.dbType;
+            }
+            oraParameters[parameter.name] = oraParameter;
+        }
+    if (options && options.autoincrementalData)
+        oraParameters['ScalarOutput'] = { val: null, dir: oracledb.BIND_OUT, type: oracledb.NUMBER };
+    return oraParameters
+}
+
+const getOraOptions = function (options , bindDefs) {
+    let oraOptions = { autoCommit: !options.isTransactionRequest };
+    if (options && (options.query || options.queryOne)) {
+        oraOptions.resultSet = true;
+    }
+    if (bindDefs) {
+        oraOptions.bindDefs = bindDefs
+    }
+    return oraOptions;
+}
+
+const convertValueFromType = async function (value, type) {
+    switch (type) {
+        case 'string': {
+            return BlzBase.convertToString(value);
+        }
+        case 'integer': {
+            return  BlzBase.convertToInteger(value);
+        }
+        case 'decimal': {
+            return  BlzBase.convertToDecimal(value);
+        }
+        case 'boolean': {
+            return  BlzBase.convertToBoolean(value);
+        }
+        case 'datetime': {
+            return  BlzBase.convertToDatetime(value);
+        }
+        case 'date': {
+            return  BlzBase.convertToDate(value);
+        }
+        case 'time': {
+            return  BlzBase.convertToTime(value);
+        }
+        case 'binary': {
+            return  BlzBase.convertToBinary(value);
+        }
+        default:{
+            // If i have a clob, or special type, the case might not be straightforward
+            if (value._type.name === 'DB_TYPE_CLOB' ) {
+                return await oraResult.outBinds[parameter.name].getData();
+                break;
+            }
+        }
+    }
+}
+
+const getResult = async function (parameters, oraResult, options) {
+    let result = {};
+    result.rowsAffected = oraResult.rowsAffected;
+    result.outParameters = {};
+    if (parameters)
+        for (let i = 0; i < parameters.length; i++) {
+            let parameter = parameters[i];
+            if (parameter.direction === 'out' || parameter.direction === 'in/out') {
+                let value = oraResult.outBinds[parameter.name];
+                if (parameter.isResultSet)
+                    value = await convertResultSetToArray(value, []);
+                else {
+                    if (value && typeof value.type === 'string') {
+                        value = await convertValueFromType(value, value.type);
+                    } else if (value && value._type && typeof value._type.name === 'string' && value._type.name === 'DB_TYPE_CLOB') {
+                        value = await oraResult.outBinds[parameter.name].getData();
+                    } else if (parameter && typeof parameter.type === 'string') {
+                        value = await convertValueFromType(value, parameter.type);
+                    } else {
+                        console.warn('Could not resolve out parameter type');
+                    }
+                }
+                result.outParameters[parameter.name] = value;
+            }
+        }
+    if (options && options.autoincrementalData) {
+        result.id = null;
+        if (oraResult.outBinds && oraResult.outBinds.ScalarOutput) {
+            result.id = oraResult.outBinds.ScalarOutput;
+            if (Array.isArray(result.id))
+                result.id = result.id[0];
+        }
+    }
+    if (options && (options.query || options.queryOne))
+        result.resultSet = oraResult.resultSet;
+    return result;
+}
+
+process.on('exit', async function () {
+    let promises = [];
+    for (let poolName in poolsByName) {
+        let pool = poolsByName[poolName];
+        promises.push(pool.close());
+    }
+    poolsByName = null;
+    await Promise.all(promises);
+});
+
+const getValue = function (source, type) {
+    const _type =  type ? type.toLowerCase() : typeof source   
+    switch (_type.toLowerCase()) {
+		case 'boolean':
+			return source ? 1 : 0
+		case 'string':
+			return typeof source === 'string' || source === null || source === undefined ? source : source.toString()
+		case 'datetime':
+		case 'date':
+		case 'time':
+			return source ? new Date(source) : null
+		default:
+			return source
+		}
+}
+
+/**
+ * Infers the Oracle DB type from a JavaScript value.
+ * @param {*} value - The value to infer the DB type for.
+ * @returns {number} oracledb type constant.
+ */
+const inferDbTypeFromValue = function (value) {
+    if (value === null || value === undefined) {
+        return oracledb.STRING; // default to STRING for nulls
+    }
+
+    if (Buffer.isBuffer(value)) {
+        return getParameterType('binary');
+    }
+
+    const jsType = typeof value;
+
+    switch (jsType) {
+        case 'string':
+            return getParameterType('string');
+        case 'number':
+            // Decide between integer and decimal if needed
+            return Number.isInteger(value) ? getParameterType('integer') : getParameterType('decimal');
+        case 'boolean':
+            return getParameterType('boolean');
+        case 'object':
+            if (value instanceof Date) {
+                return getParameterType('datetime');
+            }
+            return getParameterType('string'); // fallback for objects
+        default:
+            return getParameterType('string');
+    }
+}
+
+
+const rowsToArray = function (columns, rows) {
+    const array = []
+    const columnsCount = columns.length
+    for (const row of rows) {
+        const item = {}
+        for(let i=0 ; i < columnsCount ; i++) {
+            const column = columns[i]            
+            const value = row[i]
+            item[column.name] = getValue(value,column.type)
+        }
+        array.push(item)
+    }
+    return array
+}
+
+module.exports = {
+    syntaxis: require('./syntaxis.json'),
+    createRdsConnection: async function (connection) {
+        try {
+            let oraPool = await getPool(connection);
+            let oraConnection = await oraPool.getConnection();            
+            return oraConnection;
+        }
+        catch (err) {
+            throw err;
+        }
+    },
+    executeSql: async function (connection, sql, parameters, options) {
+        if(_.has(options, "bulkInsert")) {
+            return await this._executeBulkInsert(connection, sql, parameters, options);    
+        } else if(_.has(options, "bulkMerge")) {
+            return await this._executeBulkMerge(connection, sql, parameters, options);    
+        } else {
+            return await this._executeSql(connection, sql, parameters, options);
+        }
+    },
+    _executeSql: async function (connection, sql, parameters, options) {
+        try{
+            let oraParameters = getOraParameters(parameters,options);
+            let oraOptions = getOraOptions(options)
+            let oraResult = await connection.execute(sql, oraParameters, oraOptions);
+            const result = await getResult(parameters, oraResult, options);
+            return result;
+        } catch (err) {
+            throw err
+        }
+    },
+    _executeBulkInsert: async function (connection, sql, rows, options) {
+        let autoincremental = null
+        if (options.autoincrementalData && options.autoincrementalData.pkColumnName) { 
+            autoincremental = { name: options.autoincrementalData.pkColumnName ,
+                         alias: options.autoincrementalData.pkColumnAlias,
+                         sequence: options.autoincrementalData.sequenceName,
+                         type: options.autoincrementalData.pkColumnType
+                        }
+        }
+        const _sql = autoincremental ? 
+                    'INSERT INTO ' + options.rdsTable.tableName + 
+                    ' (' + autoincremental.name + ',' + options.setsFields.join(', ') + 
+                    ') VALUES ( ' + autoincremental.sequence + '.NEXTVAL, ' + options.setsFields.map((field) => ':' + field).join(', ') + ' ) ' +
+                    ' RETURNING ' + autoincremental.name + ' INTO :' + autoincremental.name  
+                : sql + '(' +options.setsFields.map((field) => ':' + field).join(', ') + ' ) ' 
+        
+        // solve max size for string fields
+        const columnsCount = options.columns.length        
+		for(let i=0 ; i < columnsCount ; i++) {
+            const column = options.columns[i]
+            if (column.type === 'string') {
+                column.size =  rows.reduce((max, row) => { return !row[i]?0:row[i].length > max ? row[i].length : max }, 0)           
+            }
+        }
+        const bindDefs = {}
+		for (const column of options.columns) {
+            const bindDef = { type:getDbType(column.type) }
+            if (column.type === 'string') {
+                bindDef.maxSize = column.size
+            }
+			bindDefs[column.name] = bindDef
+		}
+        if (autoincremental) {
+			bindDefs[autoincremental.name] = { type: getDbType(autoincremental.type), dir: oracledb.BIND_OUT}
+		}
+        const oraOptions = getOraOptions(options,bindDefs)
+        const data = rowsToArray(options.columns,rows)
+        try {   
+            const result = await connection.executeMany(_sql, data, oraOptions)
+            if (autoincremental) {
+                const ids = []
+                for (const i in result.outBinds) {
+                    ids.push(result.outBinds[i][autoincremental.name][0])
+                }
+                return { rowsAffected: result.rowsAffected, ids }
+            } else {
+                return { rowsAffected: result.rowsAffected }
+            }
+        } catch (err) {
+            console.log(err)
+            throw err
+        }       
+    },
+    _executeBulkMerge: async function (connection, sql, rows, options) {
+        // example: https://stackoverflow.com/questions/67881781/how-to-execute-multiple-merge-into-query-on-oracle-db-from-node-js
+        let autoincremental = null
+        if (options.autoincrementalData && options.autoincrementalData.pkColumnName) { 
+            autoincremental = { name: options.autoincrementalData.pkColumnName ,
+                         alias: options.autoincrementalData.pkColumnAlias,
+                         sequence: options.autoincrementalData.sequenceName,
+                         type: options.autoincrementalData.pkColumnType
+                        }
+        }
+        const _sql = []
+        _sql.push('MERGE INTO ' + options.rdsTable.tableName + ' t USING (')        
+        _sql.push('SELECT ')
+        let first = true
+        for (const column of options.columns) {
+            _sql.push((first?'': ', ') + ':' + column.name + ' AS ' + column.name)
+            first = false
+        }
+        _sql.push('FROM DUAL')
+        _sql.push(') s ON (')
+        first = true        
+        for(const field of options.mergeFields) {
+            _sql.push((first?'': ' AND ') + 't.' + field + ' = s.' + field )
+            first = false
+        }
+        _sql.push(')')
+        _sql.push('WHEN MATCHED THEN UPDATE SET ')
+        first = true
+        for(const column of options.columns) {
+            if(options.mergeFields.includes(column.name)) continue
+            _sql.push((first?'': ',') + 't.' + column.name + ' = s.' + column.name)
+            first = false
+        }
+        _sql.push('WHEN NOT MATCHED THEN INSERT (')
+        if(autoincremental) {
+            _sql.push(autoincremental.name)
+            for(const column of options.columns) {
+                _sql.push(',' + column.name)
+            }
+            _sql.push(') VALUES (')
+            _sql.push(autoincremental.sequence + '.NEXTVAL')
+            for(const column of options.columns) {
+                _sql.push(',s.' + column.name)
+            }
+        } else {
+            first = true
+            for(const column of options.columns) {
+                _sql.push((first?'': ',') + column.name)
+                first = false
+            }
+            _sql.push(') VALUES (')
+            first = true
+            for(const column of options.columns) {
+                _sql.push((first?'': ',') + 's.' + column.name)
+                first = false
+            }
+        }
+        _sql.push(')')
+        const mergeSql = _sql.join(' ')
+        
+        // solve max size for string fields
+        const columnsCount = options.columns.length        
+		for(let i=0 ; i < columnsCount ; i++) {
+            const column = options.columns[i]
+            if (column.type === 'string') {
+                column.size =  rows.reduce((max, row) => { return !row[i]?0:row[i].length > max ? row[i].length : max }, 0)           
+            }
+        }
+        const bindDefs = {}
+		for (const column of options.columns) {
+            const bindDef = { type:getDbType(column.type) }
+            if (column.type === 'string') {
+                bindDef.maxSize = column.size
+            }
+			bindDefs[column.name] = bindDef
+		}
+        const oraOptions = getOraOptions(options,bindDefs)
+        const data = rowsToArray(options.columns,rows)
+        try {   
+            const result = await connection.executeMany(mergeSql, data, oraOptions)
+            return { rowsAffected: result.rowsAffected }
+        } catch (err) {
+            console.log(err)
+            throw err
+        }       
+    },
+    close(nativeConnection) {
+        return nativeConnection.close();
+    },
+    beginTransaction(nativeConnection) {
+        //se utiliza la variable isTransactionRequest
+    },
+    commitTransaction(nativeConnection) {
+        return nativeConnection.commit();
+    },
+    rollbackTransaction(nativeConnection) {
+        return nativeConnection.rollback();
+    }
+};

package/blz-rds-oracle/syntaxis.json

@@ -0,0 +1,112 @@
+{
+    "selectWithPaging1": "select /*+ FIRST_ROWS */ templimit.* from (SELECT %1$s) templimit where rownum <= %3$s",
+    "selectWithPagingN": "select res.* from (select /*+ FIRST_ROWS */ templimit.*, rownum r from (SELECT %1$s) templimit where rownum <= %3$s) res where r > %2$s",
+    "insertAutoIncremental": "INSERT INTO %1$s (%3$s, %4$s) VALUES (%2$s.NEXTVAL, %5$s) RETURNING %3$s INTO :ScalarOutput",
+    "insertConditional":"BEGIN \r\n INSERT INTO %1$s (%4$s) SELECT %5$s FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM %1$s WHERE %6$s);\r\nSELECT %3$s INTO :ScalarOutput FROM %1$s WHERE %6$s AND ROWNUM = 1;\r\nEND;",
+    "insertConditionalAutoIncremental":"DECLARE\r\n v_ID %1$s.%3$s%TYPE;\r\nBEGIN\r\nSELECT %2$s.NEXTVAL INTO v_ID FROM DUAL;\r\nINSERT INTO %1$s (%3$s, %4$s) SELECT v_ID, %5$s FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM %1$s WHERE %6$s);\r\nIF SQL%ROWCOUNT = 1 THEN\r\nSELECT v_ID INTO :ScalarOutput FROM dual;\r\nEND IF;\r\nEND;",
+    "selectExists": "SELECT CASE WHEN %1$s THEN 1 ELSE 0 END FROM DUAL",
+    "executeStoredProcedure": "BEGIN %1$s(%2$s); END;",
+    "storedProcedureResultSet": "explicit",
+    "core": {
+        "asc": "%1$s ASC NULLS FIRST",
+        "avg": "ROUND(AVG(%1$s), 8)",
+        "count": "COUNT(%1$s)",
+        "countDistinct": "COUNT(DISTINCT %1$s)",
+        "desc": "%1$s DESC NULLS LAST",
+        "divide" : "(%1$s / %2$s)",
+        "distinct": "DISTINCT %1$s",
+        "false": "0",
+        "isNotNull": "(%1$s IS NOT NULL)",
+        "isNull": "(%1$s IS NULL)",
+        "like": "(%1$s LIKE %2$s)",
+        "max": "MAX(%1$s)",
+        "min": "MIN(%1$s)",
+        "nvl": "NVL(%1$s, %2$s)",
+        "parameter": ":%1$s",
+        "remainder": "MOD(%1$s, %2$s)",
+        "sum": "SUM(%1$s)",
+        "true" : "1"
+    },
+    "datetimes":{
+        "addDays": "(%1$s+%2$s)",
+        "addHours": "(%1$s+(%2$s/24))",
+        "addMilliseconds": "(%1$s+(%2$s/(24*60*60*1000)))",
+        "addMinutes": "(%1$s+(%2$s/(24*60)))",
+        "addMonths": "ADD_MONTHS(%1$s, %2$s)",
+        "addSeconds": "(%1$s+(%2$s/(24*60*60)))",
+        "addYears": "ADD_MONTHS(%1$s, %2$s*12)",
+        "date": "TO_DATE('%1$s-%2$s-%3$s 00:00:00','YYYY-MM-DD HH24:MI:SS')",
+        "dateDiff": "(%1$s-%2$s)",
+        "datetime": "TO_DATE('%1$s-%2$s-%3$s %4$s:%5$s:%6$s','YYYY-MM-DD HH24:MI:SS')",
+        "datetimeDiff": "((%1$s-%2$s)*24*60*60*1000)",
+        "day": "TO_NUMBER(TO_CHAR(%1$s,'DD'))",
+        "hour": "TO_NUMBER(TO_CHAR(%1$s,'HH24'))",
+        "millisecond": "(CASE WHEN %1$s IS NULL THEN NULL ELSE 0 END)",
+        "minute": "TO_NUMBER(TO_CHAR(%1$s,'MI'))",
+        "month": "TO_NUMBER(TO_CHAR(%1$s,'MM'))",
+        "monthText": "TRIM(TO_CHAR(%1$s,'Month'))",
+        "now": "CAST(SYSTIMESTAMP AT TIME ZONE 'UTC' AS DATE)",
+        "second": "TO_NUMBER(TO_CHAR(%1$s,'SS'))",
+        "subtractDays": "(%1$s-%2$s)",
+        "subtractMilliseconds": "(%1$s-(%2$s/(24*60*60*1000)))",
+        "subtractMinutes": "(%1$s-(%2$s/(24*60)))",
+        "subtractSeconds": "(%1$s-(%2$s/(24*60*60)))",
+        "time": "TO_DATE('1970-01-01 %1$s:%2$s:%3$s','YYYY-MM-DD HH24:MI:SS')",
+        "timeDiff": "((%1$s-%2$s)*24*60*60*1000)",
+        "today": "TRUNC(CAST(SYSTIMESTAMP AT TIME ZONE 'UTC' AS DATE))",
+        "week": "TO_NUMBER(TO_CHAR(%1$s,'WW'))",
+        "weekDay": "(TO_NUMBER(TO_CHAR(%1$s,'D'))-1)",
+        "weekDayText": "TO_CHAR(%1$s,'FmDay','nls_date_language=english')",
+        "year": "TO_NUMBER(TO_CHAR(%1$s,'YYYY'))"
+    },
+    "math":{
+        "abs": "ABS(%1$s)",
+        "acos": "ACOS(%1$s)",
+        "asin": "ASIN(%1$s)",
+        "atan": "ATAN(%1$s)",
+        "atan2": "ATAN2(%2$s,%1$s)",
+        "ceil": "CEIL(%1$s)",
+        "cos": "COS(%1$s)",
+        "cosh": "COSH(%1$s)",
+        "exp": "EXP(%1$s)",
+        "floor": "FLOOR(%1$s)",
+        "logBase": "LOG(%2$s,%1$s)",
+        "log": "LOG(EXP(1),%1$s)",
+        "log10": "LOG(10,%1$s)",
+        "pow": "POWER(%1$s,%2$s)",
+        "random": "DBMS_RANDOM.VALUE",
+        "round": "ROUND(%1$s)",
+        "roundWithDecimals": "ROUND(%1$s,%2$s)",
+        "sign": "SIGN(%1$s)",
+        "sin": "SIN(%1$s)",
+        "sinh": "SINH(%1$s)",
+        "sqrt": "SQRT(%1$s)",
+        "tan": "TAN(%1$s)",
+        "tanh": "TANH(%1$s)",
+        "trunc": "TRUNC(%1$s)",
+        "truncWithDecimals": "TRUNC(%1$s,%2$s)"
+    },
+    "strings": {
+        "concat": "({[ || ]})",
+        "contains": "(INSTR(%1$s,%2$s)>0)",
+        "endsWith": "REGEXP_LIKE(%1$s,'(*)'||%2$s||'$')",
+        "indexOf": "(NVL(INSTR(%1$s,%2$s),0)-1)",
+        "isNullOrEmpty": "(NVL(LENGTH(%1$s),0)=0) OR (%1$s IS NULL)",
+        "isNullOrWhiteSpace": "(NVL(LENGTH(TRIM(%1$s)),0)=0) OR (%1$s IS NULL)",
+        "join": "({[ || %1$s || ]})",
+        "lastIndexOf": "(NVL(INSTR(%1$s,%2$s,-1),0)-1)",
+        "length": "NVL(LENGTH(%1$s),0)",
+        "padLeft": "LPAD(%1$s,%2$s)",
+        "padLeftPattern": "LPAD(%1$s,%2$s,%3$s)",
+        "padRight": "RPAD(%1$s,%2$s)",
+        "padRightPattern": "RPAD(%1$s,%2$s,%3$s)",
+        "replace": "REPLACE(%1$s,%2$s,%3$s)",
+        "startsWith": "REGEXP_LIKE(%1$s,'^'||%2$s||'(*)')",
+        "substring": "SUBSTR(%1$s,%2$s+1,%3$s)",
+        "toLower": "LOWER(%1$s)",
+        "toUpper": "UPPER(%1$s)",
+        "trim": "TRIM(%1$s)",
+        "trimEnd": "RTRIM(%1$s)",
+        "trimStart": "LTRIM(%1$s)"
+    }
+}