@blazedpath/commons 0.0.4

package/blz-rds/blz-rds-helper.js

@@ -0,0 +1,310 @@
+let commands = {
+    // core
+    add: require('./commands/core/add.js'),
+    and: require('./commands/core/and.js'),
+    asc: require('./commands/core/asc.js'),
+    avg: require('./commands/core/avg.js'),
+    columnRef: require('./commands/core/column-ref.js'),
+    count: require('./commands/core/count.js'),
+    countDistinct: require('./commands/core/count-distinct.js'),
+    decimal: require('./commands/core/decimal.js'),
+    desc: require('./commands/core/desc.js'),
+    distinct: require('./commands/core/distinct.js'),
+    divide: require('./commands/core/divide.js'),
+    embeddedExists: require('./commands/core/embedded-exists.js'),
+    embeddedSelect: require('./commands/core/embedded-select.js'),
+    equals: require('./commands/core/equals.js'),
+    false: require('./commands/core/false.js'),
+    greater: require('./commands/core/greater.js'),
+    greaterOrEqual: require('./commands/core/greater-or-equal.js'),
+    in: require('./commands/core/in.js'),
+    integer: require('./commands/core/integer.js'),
+    isNotNull: require('./commands/core/is-not-null.js'),
+    isNull: require('./commands/core/is-null.js'),
+    isNullOrValue: require('./commands/core/is-null-or-value.js'),
+    less: require('./commands/core/less.js'),
+    lessOrEqual: require('./commands/core/less-or-equal.js'),
+    lessUnary: require('./commands/core/less-unary.js'),
+    like: require('./commands/core/like.js'),
+    max: require('./commands/core/max.js'),
+    min: require('./commands/core/min.js'),
+    multiply: require('./commands/core/multiply.js'),
+    not: require('./commands/core/not.js'),
+    notEquals: require('./commands/core/not-equals.js'),
+    notIn: require('./commands/core/not-in.js'),
+    null: require('./commands/core/null.js'),
+    nvl: require('./commands/core/nvl.js'),
+    or: require('./commands/core/or.js'),
+    parameter: require('./commands/core/parameter.js'),
+    parameterOut: require('./commands/core/parameter.js'),
+    remainder: require('./commands/core/remainder.js'),
+    string: require('./commands/core/string.js'),
+    subtract: require('./commands/core/subtract.js'),
+    sum: require('./commands/core/sum.js'),
+    true: require('./commands/core/true.js'),
+    tuple: require('./commands/core/tuple.js'),
+    // datetimes
+    addDays: require('./commands/datetimes/add-days.js'),
+    addHours: require('./commands/datetimes/add-hours.js'),
+    addMilliseconds: require('./commands/datetimes/add-milliseconds.js'),
+    addMinutes: require('./commands/datetimes/add-minutes.js'),
+    addMonths: require('./commands/datetimes/add-months.js'),
+    addSeconds: require('./commands/datetimes/add-seconds.js'),
+    addYears: require('./commands/datetimes/add-years.js'),
+    date: require('./commands/datetimes/date.js'),
+    dateDiff: require('./commands/datetimes/date-diff.js'),
+    datetime: require('./commands/datetimes/datetime.js'),
+    datetimeDiff: require('./commands/datetimes/datetime-diff.js'),
+    day: require('./commands/datetimes/day.js'),
+    hour: require('./commands/datetimes/hour.js'),
+    millisecond: require('./commands/datetimes/millisecond.js'),
+    minute: require('./commands/datetimes/minute.js'),
+    month: require('./commands/datetimes/month.js'),
+    monthText: require('./commands/datetimes/month-text.js'),
+    now: require('./commands/datetimes/now.js'),
+    second: require('./commands/datetimes/second.js'),
+    subtractDays: require('./commands/datetimes/subtract-days.js'),
+    subtractHours: require('./commands/datetimes/subtract-hours.js'),
+    subtractMilliseconds: require('./commands/datetimes/subtract-milliseconds.js'),
+    subtractMinutes: require('./commands/datetimes/subtract-minutes.js'),
+    subtractSeconds: require('./commands/datetimes/subtract-seconds.js'),
+    time: require('./commands/datetimes/time.js'),
+    timeDiff: require('./commands/datetimes/time-diff.js'),
+    today: require('./commands/datetimes/today.js'),
+    week: require('./commands/datetimes/week.js'),
+    weekDay: require('./commands/datetimes/week-day.js'),
+    weekDayText: require('./commands/datetimes/week-day-text.js'),
+    year: require('./commands/datetimes/year.js'),
+    // math
+    abs: require('./commands/math/abs.js'),
+    acos: require('./commands/math/acos.js'),
+    asin: require('./commands/math/asin.js'),
+    atan: require('./commands/math/atan.js'),
+    atan2: require('./commands/math/atan2.js'),
+    ceil: require('./commands/math/ceil.js'),
+    cos: require('./commands/math/cos.js'),
+    cosh: require('./commands/math/cosh.js'),
+    exp: require('./commands/math/exp.js'),
+    floor: require('./commands/math/floor.js'),
+    log: require('./commands/math/log.js'),
+    log10: require('./commands/math/log10.js'),
+    pow: require('./commands/math/pow.js'),
+    random: require('./commands/math/random.js'),
+    round: require('./commands/math/round.js'),
+    sign: require('./commands/math/sign.js'),
+    sin: require('./commands/math/sin.js'),
+    sinh: require('./commands/math/sinh.js'),
+    sqrt: require('./commands/math/sqrt.js'),
+    tan: require('./commands/math/tan.js'),
+    tanh: require('./commands/math/tanh.js'),
+    trunc: require('./commands/math/trunc.js'),
+    // strings
+    concat: require('./commands/strings/concat.js'),
+    contains: require('./commands/strings/contains.js'),
+    endsWith: require('./commands/strings/ends-with.js'),
+    indexOf: require('./commands/strings/index-of.js'),
+    isNullOrEmpty: require('./commands/strings/is-null-or-empty.js'),
+    isNullOrWhiteSpace: require('./commands/strings/is-null-or-white-space.js'),
+    join: require('./commands/strings/join.js'),
+    lastIndexOf: require('./commands/strings/last-index-of.js'),
+    length: require('./commands/strings/length.js'),
+    padLeft: require('./commands/strings/pad-left.js'),
+    padRight: require('./commands/strings/pad-right.js'),
+    replace: require('./commands/strings/replace.js'),
+    startsWith: require('./commands/strings/starts-with.js'),
+    substring: require('./commands/strings/substring.js'),
+    toLower: require('./commands/strings/to-lower.js'),
+    toUpper: require('./commands/strings/to-upper.js'),
+    trim: require('./commands/strings/trim.js'),
+    trimEnd: require('./commands/strings/trim-end.js'),
+    trimStart: require('./commands/strings/trim-start.js')
+};
+
+let getSql = function (rdsNode, rdsSyntaxis, values, asLogical) {
+    if (rdsNode.condition !== undefined && !rdsNode.condition)
+        return null;
+    let command = commands[rdsNode.command];
+    let sql = command.getSql(this, rdsNode, rdsSyntaxis, values);
+    if (asLogical)
+        return command.logical ? sql : ('(' + sql + ' = ' + rdsSyntaxis.core.true + ')');
+    else
+        return command.logical ? '(CASE WHEN ' + sql + ' THEN ' + rdsSyntaxis.core.true + ' ELSE ' + rdsSyntaxis.core.false + ' END)' : sql;
+};
+
+let getType = function (rdsNode) {
+    let command = commands[rdsNode.command];
+    return command.getType(this, rdsNode);
+};
+
+let stringFormat = function () {
+    if (arguments.length === 0) {
+        return null;
+    }
+    else if (arguments.length === 1) {
+        return arguments[0];
+    }
+    else {
+        let result = arguments[0];
+        for (let i = 1; i < arguments.length; i++) {
+            result = result.split('%' + i + '$s').join(arguments[i]);
+        }
+        return result;
+    }
+};
+
+let isValidCodePath = function (connection, rdsTable, codePath) {
+    let lastIndexOfPoint = codePath.lastIndexOf('.');
+    if (lastIndexOfPoint === -1) {
+        let column = findColumnByAlias(rdsTable, codePath);
+        if (column === null || column === undefined)
+            return false;
+    }
+    else {
+        let firstPart = codePath.substring(0, lastIndexOfPoint);
+        let lastPart = codePath.substring(lastIndexOfPoint + 1, codePath.length);
+        let codePathParts = firstPart.split('.');
+        let currentRdsTable = rdsTable;
+        for (let i = 0; i < codePathParts.length; i++) {
+            let codePathPart = codePathParts[i];
+            let foreignKey = findForeignKeyByAlias(currentRdsTable, codePathPart);
+            if (foreignKey === null || foreignKey === undefined)
+                return false;
+            currentRdsTable = connection.rdsElements[foreignKey.rdsTableName];
+        }
+        let column = findColumnByAlias(currentRdsTable, lastPart);
+        if (column === null || column === undefined)
+            return false;
+    }
+    return true;
+};
+let prebuild = function (connection, rdsNode, embeddeds) {
+    if (rdsNode.condition !== undefined && !rdsNode.condition)
+        return;
+    if (rdsNode.command === 'embeddedSelect') {
+        rdsNode.embedded = { rdsTable: connection.rdsElements[rdsNode.embeddedSelect.rdsTableName], rdsJoins: [], allowLevels: true };
+        embeddeds[rdsNode.embeddedSelect.embeddedIndex] = rdsNode.embedded;
+        prebuild(connection, rdsNode.embeddedSelect.field, embeddeds);
+        if (rdsNode.embeddedSelect.where)
+            prebuild(connection, rdsNode.embeddedSelect.where, embeddeds);
+    }
+    else if (rdsNode.command === 'embeddedExists') {
+        rdsNode.embedded = { rdsTable: connection.rdsElements[rdsNode.embeddedExists.rdsTableName], rdsJoins: [], allowLevels: true };
+        embeddeds[rdsNode.embeddedExists.embeddedIndex] = rdsNode.embedded;
+        if (rdsNode.embeddedExists.where)
+            prebuild(connection, rdsNode.embeddedExists.where, embeddeds);
+    }
+    else {
+        if (rdsNode.command === 'columnRef') {
+            let embedded = embeddeds[rdsNode.columnRef.embeddedIndex];
+            let aliasPrefix = 'T' + (rdsNode.columnRef.embeddedIndex === 0 ? '' : (rdsNode.columnRef.embeddedIndex + '_'));
+            let codePath = rdsNode.columnRef.codePath;
+            if (embedded.allowLevels) {
+                let lastIndexOfPoint = codePath.lastIndexOf('.');
+                if (lastIndexOfPoint === -1) {
+                    let column = findColumnByAlias(embedded.rdsTable, codePath);
+                    rdsNode.sql = aliasPrefix + '0.' + column.name;
+                    rdsNode.type = column.type;
+                }
+                else {
+                    let firstPart = codePath.substring(0, lastIndexOfPoint);
+                    let lastPart = codePath.substring(lastIndexOfPoint + 1, codePath.length);
+                    let codePathParts = firstPart.split('.');
+                    let currentCodePath = null;
+                    let currentRdsJoin = null;
+                    for (let i = 0; i < codePathParts.length; i++) {
+                        let codePathPart = codePathParts[i];
+                        currentCodePath = (currentCodePath === null) ? codePathPart : (currentCodePath + '.' + codePathPart);
+                        let rdsJoin = findRdsJoin(embedded.rdsJoins, currentCodePath);
+                        if (rdsJoin === null) {
+                            let foreignKey = findForeignKeyByAlias(currentRdsJoin ? currentRdsJoin.rdsTable : embedded.rdsTable, codePathPart);
+                            rdsJoin = {};
+                            rdsJoin.codePath = currentCodePath;
+                            rdsJoin.rdsTable = connection.rdsElements[foreignKey.rdsTableName];
+                            rdsJoin.isLeftJoin = currentRdsJoin ? currentRdsJoin.isLeftJoin : false;
+                            rdsJoin.aliasIndex = embedded.rdsJoins.length + 1;
+                            let sqlsConditions = [];
+                            if (foreignKey.details) {
+                                for (let j = 0; j < foreignKey.details.length; j++) {
+                                    let foreignKeyDetail = foreignKey.details[j];
+                                    let rdsAliasIndex1 = null;
+                                    let column1 = null;
+                                    if (currentRdsJoin) {
+                                        rdsAliasIndex1 = currentRdsJoin.aliasIndex;
+                                        column1 = findColumnByName(currentRdsJoin.rdsTable, foreignKeyDetail.columnName);
+                                    }
+                                    else {
+                                        rdsAliasIndex1 = 0;
+                                        column1 = findColumnByName(embedded.rdsTable, foreignKeyDetail.columnName);
+                                    }
+                                    let rdsAliasIndex2 = rdsJoin.aliasIndex;
+                                    let column2 = findColumnByName(rdsJoin.rdsTable, foreignKeyDetail.relatedColumnName);
+                                    sqlsConditions.push(aliasPrefix + rdsAliasIndex1 + '.' + column1.name + ' = ' + aliasPrefix + rdsAliasIndex2 + '.' + column2.name);
+                                    rdsJoin.isLeftJoin = rdsJoin.isLeftJoin || column1.allowNull;
+                                }
+                            }
+                            rdsJoin.sql = (rdsJoin.isLeftJoin ? 'LEFT' : 'INNER') + ' JOIN ' + rdsJoin.rdsTable.tableName + ' ' + aliasPrefix + rdsJoin.aliasIndex + ' ON ' + sqlsConditions.join(' AND ');
+                            embedded.rdsJoins.push(rdsJoin);
+                        }
+                        currentRdsJoin = rdsJoin;
+                    }
+                    let column = findColumnByAlias(currentRdsJoin.rdsTable, lastPart);
+                    rdsNode.sql = aliasPrefix + currentRdsJoin.aliasIndex + '.' + column.name;
+                    rdsNode.type = column.type;
+                }
+            }
+            else {
+                let column = findColumnByAlias(embedded.rdsTable, codePath);
+                rdsNode.sql = column.name;
+                rdsNode.type = column.type;
+            }
+        }
+        if (rdsNode.children)
+            for (let i = 0; i < rdsNode.children.length; i++) {
+                let childRdsNode = rdsNode.children[i];
+                prebuild(connection, childRdsNode, embeddeds);
+            }
+    }
+};
+let findRdsJoin = function (rdsJoins, codePath) {
+    for (let i = 0; i < rdsJoins.length; i++) {
+        let rdsJoin = rdsJoins[i];
+        if (rdsJoin.codePath === codePath)
+            return rdsJoin;
+    }
+    return null;
+};
+let findColumnByName = function (rdsTable, name) {
+    if (rdsTable.columns)
+        for (let i = 0; i < rdsTable.columns.length; i++) {
+            let column = rdsTable.columns[i];
+            if (column.name === name)
+                return column;
+        }
+    return null;
+};
+let findColumnByAlias = function (rdsTable, alias) {
+    if (rdsTable.columns)
+        for (let i = 0; i < rdsTable.columns.length; i++) {
+            let column = rdsTable.columns[i];
+            if (column.alias === alias)
+                return column;
+        }
+    return null;
+};
+let findForeignKeyByAlias = function (rdsTable, alias) {
+    if (rdsTable.foreignKeys)
+        for (let i = 0; i < rdsTable.foreignKeys.length; i++) {
+            let foreignKey = rdsTable.foreignKeys[i];
+            if (foreignKey.alias === alias)
+                return foreignKey;
+        }
+    return null;
+};
+
+module.exports = {
+    getSql: getSql,
+    getType: getType,
+    stringFormat: stringFormat,
+    isValidCodePath: isValidCodePath,
+    prebuild: prebuild
+};

package/blz-rds/commands/core/add.js

@@ -0,0 +1,13 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return '(' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ' + ' + rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values) + ')';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        let type1 = rdsHelper.getType(rdsNode.children[0]);
+        let type2 = rdsHelper.getType(rdsNode.children[1]);
+        if (type1 === 'decimal' || type2 === 'decimal')
+            return 'decimal';
+        else
+            return 'integer';
+    }
+};

package/blz-rds/commands/core/and.js

@@ -0,0 +1,18 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        let parts = [];
+        for (let i = 0; i < rdsNode.children.length; i++) {
+            let part = rdsHelper.getSql(rdsNode.children[i], rdsSyntaxis, values, true);
+            if (part)
+                parts.push(part);
+        }
+        if (parts.length > 0)
+            return '(' + parts.join(' AND ') + ')';
+        else
+            return null;
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/asc.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.asc,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsHelper.getType(rdsNode.children[0]);
+    }
+};

package/blz-rds/commands/core/avg.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.avg,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsHelper.getType(rdsNode.children[0]);
+    }
+};

package/blz-rds/commands/core/column-ref.js

@@ -0,0 +1,8 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsNode.sql;
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsNode.type;
+    }
+};

package/blz-rds/commands/core/count-distinct.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.countDistinct,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'integer';
+    }
+};

package/blz-rds/commands/core/count.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.count,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'integer';
+    }
+};

package/blz-rds/commands/core/decimal.js

@@ -0,0 +1,8 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsNode.decimalValue + '';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'decimal';
+    }
+};

package/blz-rds/commands/core/desc.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.desc,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsHelper.getType(rdsNode.children[0]);
+    }
+};

package/blz-rds/commands/core/distinct.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.distinct,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsHelper.getType(rdsNode.children[0]);
+    }
+};

package/blz-rds/commands/core/divide.js

@@ -0,0 +1,11 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.divide,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values),
+            rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'decimal';
+    }
+};

package/blz-rds/commands/core/embedded-exists.js

@@ -0,0 +1,17 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        let sql = 'EXISTS(SELECT 1 FROM ' + rdsNode.embedded.rdsTable.tableName + ' T' + rdsNode.embeddedExists.embeddedIndex + '_0';
+        for (let i = 0; i < rdsNode.embedded.rdsJoins.length; i++) {
+            let rdsJoin = rdsNode.embedded.rdsJoins[i];
+            sql += ' ' + rdsJoin.sql;
+        }
+        if (rdsNode.embeddedExists.where)
+            sql += ' WHERE ' + rdsHelper.getSql(rdsNode.embeddedExists.where, rdsSyntaxis, values, true);
+        sql += ')';
+        return sql;
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/embedded-select.js

@@ -0,0 +1,17 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        let sql = '(SELECT ' + rdsHelper.getSql(rdsNode.embeddedSelect.field, rdsSyntaxis, values);
+        sql += ' FROM ' + rdsNode.embedded.rdsTable.tableName + ' T' + rdsNode.embeddedSelect.embeddedIndex + '_0';
+        for (let i = 0; i < rdsNode.embedded.rdsJoins.length; i++) {
+            let rdsJoin = rdsNode.embedded.rdsJoins[i];
+            sql += ' ' + rdsJoin.sql;
+        }
+        if (rdsNode.embeddedSelect.where)
+            sql += ' WHERE ' + rdsHelper.getSql(rdsNode.embeddedSelect.where, rdsSyntaxis, values, true);
+        sql += ')';
+        return sql;
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsHelper.getType(rdsNode.embeddedSelect.field);
+    }
+};

package/blz-rds/commands/core/equals.js

@@ -0,0 +1,9 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return '(' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ' = ' + rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values) + ')';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/false.js

@@ -0,0 +1,8 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsSyntaxis.core.false;
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    }
+};

package/blz-rds/commands/core/greater-or-equal.js

@@ -0,0 +1,9 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return '(' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ' >= ' + rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values) + ')';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/greater.js

@@ -0,0 +1,9 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return '(' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ' > ' + rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values) + ')';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/in.js

@@ -0,0 +1,9 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return '(' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ' IN ' + rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values) + ')';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/integer.js

@@ -0,0 +1,8 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsNode.integerValue + '';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'integer';
+    }
+};

package/blz-rds/commands/core/is-not-null.js

@@ -0,0 +1,11 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.isNotNull,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/is-null-or-value.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return '(' + rdsHelper.stringFormat(rdsSyntaxis.core.isNull, rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values)) + ' OR ' +
+            '(' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ' = ' + rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values) + '))';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/is-null.js

@@ -0,0 +1,11 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.isNull,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/less-or-equal.js

@@ -0,0 +1,9 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return '(' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ' <= ' + rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values) + ')';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/less-unary.js

@@ -0,0 +1,12 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        let parts = [];
+        for (let i = 0; i < rdsNode.children.length; i++) {
+            parts.push();
+        }
+        return '(-' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ')';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsHelper.getType(rdsNode.children[0]);
+    }
+};

package/blz-rds/commands/core/less.js

@@ -0,0 +1,9 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return '(' + rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values) + ' < ' + rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values) + ')';
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/like.js

@@ -0,0 +1,12 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.like,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values),
+            rdsHelper.getSql(rdsNode.children[1], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return 'boolean';
+    },
+    logical: true
+};

package/blz-rds/commands/core/max.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.max,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsHelper.getType(rdsNode.children[0]);
+    }
+};

package/blz-rds/commands/core/min.js

@@ -0,0 +1,10 @@
+module.exports = {
+    getSql: function (rdsHelper, rdsNode, rdsSyntaxis, values) {
+        return rdsHelper.stringFormat(
+            rdsSyntaxis.core.min,
+            rdsHelper.getSql(rdsNode.children[0], rdsSyntaxis, values));
+    },
+    getType: function (rdsHelper, rdsNode) {
+        return rdsHelper.getType(rdsNode.children[0]);
+    }
+};