Examples with AliasModifier org.teiid.translator.jdbc.AliasModifier used on opensource projects

Example 11 with AliasModifier

use of org.teiid.translator.jdbc.AliasModifier in project teiid by teiid.

the class VerticaExecutionFactory method start.

@Override
public void start() throws TranslatorException {
    super.start();
    registerFunctionModifier(SourceSystemFunctions.CHAR, new AliasModifier(CHR));
    registerFunctionModifier(SourceSystemFunctions.LCASE, new AliasModifier(LOWER));
    registerFunctionModifier(SourceSystemFunctions.UCASE, new AliasModifier(UPPER));
    registerFunctionModifier(SourceSystemFunctions.CURDATE, new AliasModifier(CURRENT_DATE));
    registerFunctionModifier(SourceSystemFunctions.CURTIME, new AliasModifier(CURRENT_TIME));
    registerFunctionModifier(SourceSystemFunctions.WEEK, new AliasModifier(WEEK_ISO));
    addPushDownFunction(VERTICA, BIT_LENGTH, INTEGER, STRING);
    addPushDownFunction(VERTICA, BITCOUNT, BYTE, BYTE);
    addPushDownFunction(VERTICA, BITSTRING_TO_BINARY, BYTE, STRING);
    addPushDownFunction(VERTICA, BTRIM, STRING, STRING, STRING);
    addPushDownFunction(VERTICA, GREATEST, OBJECT, OBJECT);
    addPushDownFunction(VERTICA, GREATESTB, BYTE, OBJECT);
    addPushDownFunction(VERTICA, HEX_TO_BINARY, BYTE, STRING);
    addPushDownFunction(VERTICA, HEX_TO_INTEGER, INTEGER, STRING);
    addPushDownFunction(VERTICA, INITCAP, STRING, STRING);
    addPushDownFunction(VERTICA, INSERT, STRING, STRING, INTEGER, INTEGER, STRING);
    addPushDownFunction(VERTICA, ISUTF8, BOOLEAN, STRING);
    addPushDownFunction(VERTICA, MD5, STRING, STRING);
    addPushDownFunction(VERTICA, SPACE, STRING, INTEGER);
    addPushDownFunction(VERTICA, TO_HEX, STRING, INTEGER);
    addPushDownFunction(VERTICA, CBRT, DOUBLE, DOUBLE);
    addPushDownFunction(VERTICA, LN, DOUBLE, DOUBLE);
    addPushDownFunction(VERTICA, PI, DOUBLE);
    addPushDownFunction(VERTICA, RANDOM, FLOAT);
    addPushDownFunction(VERTICA, TRUNC, DOUBLE, DOUBLE);
    addPushDownFunction(VERTICA, ADD_MONTHS, DATE, DATE, INTEGER);
    addPushDownFunction(VERTICA, AGE_IN_MONTHS, INTEGER, TIMESTAMP, TIMESTAMP);
    addPushDownFunction(VERTICA, AGE_IN_YEARS, INTEGER, TIMESTAMP, TIMESTAMP);
    addPushDownFunction(VERTICA, DATE_NAME, DATE, OBJECT);
    addPushDownFunction(VERTICA, DATEDIFF, INTEGER, STRING, DATE, DATE);
    addPushDownFunction(VERTICA, DAY, INTEGER, OBJECT);
    addPushDownFunction(VERTICA, GETDATE, TIMESTAMP);
    addPushDownFunction(VERTICA, GETUTCDATE, TIMESTAMP);
    addPushDownFunction(VERTICA, ISFINITE, BOOLEAN, TIMESTAMP);
    addPushDownFunction(VERTICA, LOCALTIME, TIME);
    addPushDownFunction(VERTICA, LOCALTIMESTAMP, TIMESTAMP);
    addPushDownFunction(VERTICA, MONTHS_BETWEEN, INTEGER, DATE, DATE);
    addPushDownFunction(VERTICA, OVERLAPS, BOOLEAN, DATE, DATE);
    addPushDownFunction(VERTICA, TIMESTAMPDIFF, INTEGER, TIMESTAMP, TIMESTAMP);
}

Example 12 with AliasModifier

use of org.teiid.translator.jdbc.AliasModifier in project teiid by teiid.

the class PostgreSQLExecutionFactory method start.

public void start() throws TranslatorException {
    // TODO: all of the functions (except for convert) can be handled through just the escape syntax
    super.start();
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LOG, new AliasModifier("ln"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LOG10, new AliasModifier("log"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.BITAND, new AliasModifier("&"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.BITNOT, new AliasModifier("~"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.BITOR, new AliasModifier("|"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.BITXOR, new AliasModifier("#"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.CHAR, new AliasModifier("chr"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.CONCAT, new AliasModifier("||"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LCASE, new AliasModifier("lower"));
    registerFunctionModifier(SourceSystemFunctions.SUBSTRING, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            List<Object> parts = new ArrayList<Object>();
            // $NON-NLS-1$
            parts.add("substring(");
            parts.add(function.getParameters().get(0));
            // $NON-NLS-1$
            parts.add(" from ");
            Expression index = function.getParameters().get(1);
            if (!(index instanceof Literal)) {
                // $NON-NLS-1$
                parts.add("case sign(");
                parts.add(index);
                // $NON-NLS-1$
                parts.add(") when -1 then length(");
                parts.add(function.getParameters().get(0));
                // $NON-NLS-1$
                parts.add(") + 1 + ");
                parts.add(index);
                // $NON-NLS-1$
                parts.add(" when 0 then 1 else ");
                parts.add(index);
                // $NON-NLS-1$
                parts.add(" end");
            } else {
                parts.add(index);
            }
            if (function.getParameters().size() > 2) {
                // $NON-NLS-1$
                parts.add(" for ");
                parts.add(function.getParameters().get(2));
            }
            // $NON-NLS-1$
            parts.add(")");
            return parts;
        }
    });
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.UCASE, new AliasModifier("upper"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.DAYNAME, new MonthOrDayNameFunctionModifier(getLanguageFactory(), "Day"));
    registerFunctionModifier(SourceSystemFunctions.DAYOFWEEK, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.DAYOFMONTH, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.DAYOFYEAR, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.HOUR, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.MINUTE, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.MONTH, new ExtractFunctionModifier(INTEGER_TYPE));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.MONTHNAME, new MonthOrDayNameFunctionModifier(getLanguageFactory(), "Month"));
    registerFunctionModifier(SourceSystemFunctions.QUARTER, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.SECOND, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.WEEK, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.YEAR, new ExtractFunctionModifier(INTEGER_TYPE));
    registerFunctionModifier(SourceSystemFunctions.LOCATE, new LocateFunctionModifier(getLanguageFactory()));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.IFNULL, new AliasModifier("coalesce"));
    registerFunctionModifier(SourceSystemFunctions.PARSETIMESTAMP, parseModifier);
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.FORMATTIMESTAMP, new PostgreSQLFormatFunctionModifier("TO_CHAR(", false));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.MOD, new ModFunctionModifier("%", getLanguageFactory(), Arrays.asList(TypeFacility.RUNTIME_TYPES.BIG_INTEGER, TypeFacility.RUNTIME_TYPES.BIG_DECIMAL)));
    // specific to 8.2 client or later
    registerFunctionModifier(SourceSystemFunctions.TIMESTAMPADD, new EscapeSyntaxModifier());
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.RAND, new AliasModifier("random"));
    registerFunctionModifier(SourceSystemFunctions.ARRAY_GET, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            return Arrays.asList(function.getParameters().get(0), '[', function.getParameters().get(1), ']');
        }
    });
    registerFunctionModifier(SourceSystemFunctions.ARRAY_LENGTH, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            if (function.getParameters().size() == 1) {
                function.getParameters().add(new Literal(1, TypeFacility.RUNTIME_TYPES.INTEGER));
            }
            return null;
        }
    });
    registerFunctionModifier(SourceSystemFunctions.ROUND, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            if (function.getParameters().size() > 1) {
                Expression ex = function.getParameters().get(0);
                if (ex.getType() == TypeFacility.RUNTIME_TYPES.DOUBLE || ex.getType() == TypeFacility.RUNTIME_TYPES.FLOAT) {
                    if (function.getParameters().get(1) instanceof Literal && Integer.valueOf(0).equals(((Literal) function.getParameters().get(1)).getValue())) {
                        function.getParameters().remove(1);
                    } else {
                        // $NON-NLS-1$
                        function.getParameters().set(0, new Function(SourceSystemFunctions.CONVERT, Arrays.asList(ex, new Literal("bigdecimal", TypeFacility.RUNTIME_TYPES.STRING)), TypeFacility.RUNTIME_TYPES.BIG_DECIMAL));
                    }
                }
            }
            return null;
        }
    });
    // add in type conversion
    ConvertModifier convertModifier = new ConvertModifier();
    // $NON-NLS-1$
    convertModifier.addTypeMapping("boolean", FunctionModifier.BOOLEAN);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("smallint", FunctionModifier.BYTE, FunctionModifier.SHORT);
    convertModifier.addTypeMapping(INTEGER_TYPE, FunctionModifier.INTEGER);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("bigint", FunctionModifier.LONG);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("real", FunctionModifier.FLOAT);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("float8", FunctionModifier.DOUBLE);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("numeric(38)", FunctionModifier.BIGINTEGER);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("decimal", FunctionModifier.BIGDECIMAL);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("char(1)", FunctionModifier.CHAR);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("varchar(4000)", FunctionModifier.STRING);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("date", FunctionModifier.DATE);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("time", FunctionModifier.TIME);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("timestamp", FunctionModifier.TIMESTAMP);
    convertModifier.addConvert(FunctionModifier.BIGDECIMAL, FunctionModifier.BOOLEAN, new NonIntegralNumberToBoolean());
    convertModifier.addConvert(FunctionModifier.FLOAT, FunctionModifier.BOOLEAN, new NonIntegralNumberToBoolean());
    convertModifier.addConvert(FunctionModifier.BIGDECIMAL, FunctionModifier.BOOLEAN, new NonIntegralNumberToBoolean());
    convertModifier.addConvert(FunctionModifier.TIME, FunctionModifier.TIMESTAMP, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$
            return Arrays.asList(function.getParameters().get(0), " + TIMESTAMP '1970-01-01'");
        }
    });
    convertModifier.addConvert(FunctionModifier.TIMESTAMP, FunctionModifier.TIME, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$ //$NON-NLS-2$
            return Arrays.asList("cast(date_trunc('second', ", function.getParameters().get(0), ") AS time)");
        }
    });
    // $NON-NLS-1$ //$NON-NLS-2$
    convertModifier.addConvert(FunctionModifier.DATE, FunctionModifier.STRING, new ConvertModifier.FormatModifier("to_char", "YYYY-MM-DD"));
    // $NON-NLS-1$ //$NON-NLS-2$
    convertModifier.addConvert(FunctionModifier.TIME, FunctionModifier.STRING, new ConvertModifier.FormatModifier("to_char", "HH24:MI:SS"));
    // $NON-NLS-1$ //$NON-NLS-2$
    convertModifier.addConvert(FunctionModifier.TIMESTAMP, FunctionModifier.STRING, new ConvertModifier.FormatModifier("to_char", "YYYY-MM-DD HH24:MI:SS.US"));
    convertModifier.addConvert(FunctionModifier.BOOLEAN, FunctionModifier.STRING, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            Expression stringValue = function.getParameters().get(0);
            // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
            return Arrays.asList("CASE WHEN ", stringValue, " THEN 'true' WHEN not(", stringValue, ") THEN 'false' END");
        }
    });
    convertModifier.addSourceConversion(new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            ((Literal) function.getParameters().get(1)).setValue(INTEGER_TYPE);
            return null;
        }
    }, FunctionModifier.BOOLEAN);
    registerFunctionModifier(SourceSystemFunctions.CONVERT, convertModifier);
    // standard function form of several predicates
    // $NON-NLS-1$ //$NON-NLS-2$
    addPushDownFunction(POSTGRESQL, "ilike", BOOLEAN, STRING, STRING).setProperty(SQLStringVisitor.TEIID_NATIVE_QUERY, "($1 ilike $2)");
    // $NON-NLS-1$ //$NON-NLS-2$
    addPushDownFunction(POSTGRESQL, "rlike", BOOLEAN, STRING, STRING).setProperty(SQLStringVisitor.TEIID_NATIVE_QUERY, "($1 ~ $2)");
    // $NON-NLS-1$ //$NON-NLS-2$
    addPushDownFunction(POSTGRESQL, "iregexp", BOOLEAN, STRING, STRING).setProperty(SQLStringVisitor.TEIID_NATIVE_QUERY, "($1 ~* $2)");
}

Example 13 with AliasModifier

use of org.teiid.translator.jdbc.AliasModifier in project teiid by teiid.

the class SybaseExecutionFactory method start.

public void start() throws TranslatorException {
    super.start();
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.MOD, new ModFunctionModifier("%", getLanguageFactory()));
    if (nullPlusNonNullIsNull()) {
        // $NON-NLS-1$
        registerFunctionModifier(SourceSystemFunctions.CONCAT, new AliasModifier("+"));
    } else {
        registerFunctionModifier(SourceSystemFunctions.CONCAT, new ConcatFunctionModifier(getLanguageFactory()) {

            @Override
            public List<?> translate(Function function) {
                // $NON-NLS-1$
                function.setName("+");
                return super.translate(function);
            }
        });
    }
    registerFunctionModifier(SourceSystemFunctions.LPAD, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            List<Expression> params = function.getParameters();
            return // $NON-NLS-1$
            Arrays.asList(// $NON-NLS-1$
            "RIGHT(REPLICATE(", // $NON-NLS-1$ //$NON-NLS-2$
            params.size() > 2 ? params.get(2) : new Literal(" ", TypeFacility.RUNTIME_TYPES.STRING), // $NON-NLS-1$ //$NON-NLS-2$
            ", ", params.get(1), ") + ", params.get(0), ", ", params.get(1), // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
            ")");
        }
    });
    registerFunctionModifier(SourceSystemFunctions.RPAD, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            List<Expression> params = function.getParameters();
            return // $NON-NLS-1$ //$NON-NLS-2$
            Arrays.asList(// $NON-NLS-1$ //$NON-NLS-2$
            "LEFT(", // $NON-NLS-1$ //$NON-NLS-2$
            params.get(0), // $NON-NLS-1$ //$NON-NLS-2$
            " + REPLICATE(", // $NON-NLS-1$ //$NON-NLS-2$
            params.size() > 2 ? params.get(2) : new Literal(" ", TypeFacility.RUNTIME_TYPES.STRING), // $NON-NLS-1$ //$NON-NLS-2$
            ", ", params.get(1), "), ", params.get(1), // $NON-NLS-1$ //$NON-NLS-2$
            ")");
        }
    });
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LCASE, new AliasModifier("lower"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.IFNULL, new AliasModifier("isnull"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.UCASE, new AliasModifier("upper"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.REPEAT, new AliasModifier("replicate"));
    registerFunctionModifier(SourceSystemFunctions.SUBSTRING, new SubstringFunctionModifier(getLanguageFactory()));
    registerFunctionModifier(SourceSystemFunctions.DAYNAME, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.MONTHNAME, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.DAYOFWEEK, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.DAYOFYEAR, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.DAYOFMONTH, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.HOUR, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.MINUTE, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.QUARTER, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.SECOND, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.WEEK, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.LENGTH, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.ATAN2, new EscapeSyntaxModifier());
    registerFunctionModifier(SourceSystemFunctions.TIMESTAMPADD, new EscapeSyntaxModifier() {

        @Override
        public List<?> translate(Function function) {
            if (!isFracSeconds(function)) {
                return super.translate(function);
            }
            // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
            return Arrays.asList("dateadd(millisecond, ", function.getParameters().get(1), "/1000000, ", function.getParameters().get(2), ")");
        }
    });
    registerFunctionModifier(SourceSystemFunctions.TIMESTAMPDIFF, new EscapeSyntaxModifier() {

        @Override
        public List<?> translate(Function function) {
            if (!isFracSeconds(function)) {
                return super.translate(function);
            }
            // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
            return Arrays.asList("datediff(millisecond, ", function.getParameters().get(1), ",", function.getParameters().get(2), ")*1000000");
        }
    });
    // add in type conversion
    convertModifier.setBooleanNullable(booleanNullable());
    // boolean isn't treated as bit, since it doesn't support null
    // byte is treated as smallint, since tinyint is unsigned
    // $NON-NLS-1$
    convertModifier.addTypeMapping("smallint", FunctionModifier.BYTE, FunctionModifier.SHORT);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("int", FunctionModifier.INTEGER);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("numeric(19,0)", FunctionModifier.LONG);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("real", FunctionModifier.FLOAT);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("double precision", FunctionModifier.DOUBLE);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("numeric(38, 0)", FunctionModifier.BIGINTEGER);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("numeric(38, 19)", FunctionModifier.BIGDECIMAL);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("char(1)", FunctionModifier.CHAR);
    // $NON-NLS-1$
    convertModifier.addTypeMapping("varchar(4000)", FunctionModifier.STRING);
    convertModifier.addConvert(FunctionModifier.TIMESTAMP, FunctionModifier.DATE, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            List<Object> result = new ArrayList<Object>();
            // $NON-NLS-1$
            result.add("cast(");
            result.addAll(convertDateToString(function));
            // $NON-NLS-1$
            result.add(" AS datetime)");
            return result;
        }
    });
    convertModifier.addConvert(FunctionModifier.TIME, FunctionModifier.STRING, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            return convertTimeToString(function);
        }
    });
    convertModifier.addConvert(FunctionModifier.DATE, FunctionModifier.STRING, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            return convertDateToString(function);
        }
    });
    convertModifier.addConvert(FunctionModifier.TIMESTAMP, FunctionModifier.STRING, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            return convertTimestampToString(function);
        }
    });
    convertModifier.addNumericBooleanConversions();
    registerFunctionModifier(SourceSystemFunctions.CONVERT, convertModifier);
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.PARSETIMESTAMP, new SybaseFormatFunctionModifier("CONVERT(DATETIME, ", formatMap));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.FORMATTIMESTAMP, new SybaseFormatFunctionModifier("CONVERT(VARCHAR, ", formatMap));
}

Example 14 with AliasModifier

use of org.teiid.translator.jdbc.AliasModifier in project teiid by teiid.

the class TeradataExecutionFactory method start.

@Override
public void start() throws TranslatorException {
    super.start();
    // $NON-NLS-1$
    convert.addTypeMapping("byteint", FunctionModifier.BYTE, FunctionModifier.SHORT, FunctionModifier.BOOLEAN);
    // $NON-NLS-1$
    convert.addTypeMapping("double precision", FunctionModifier.DOUBLE);
    // $NON-NLS-1$
    convert.addTypeMapping("numeric(18,0)", FunctionModifier.BIGINTEGER);
    // $NON-NLS-1$
    convert.addTypeMapping("char(1)", FunctionModifier.CHAR);
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.TIMESTAMP, FunctionModifier.TIME, new CastModifier("TIME"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.TIMESTAMP, FunctionModifier.DATE, new CastModifier("DATE"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.TIME, FunctionModifier.TIMESTAMP, new CastModifier("TIMESTAMP"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.DATE, FunctionModifier.TIMESTAMP, new CastModifier("TIMESTAMP"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.INTEGER, new CastModifier("integer"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.BIGDECIMAL, new CastModifier("decimal(37,5)"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.BIGINTEGER, new CastModifier("numeric(18,0)"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.FLOAT, new CastModifier("float"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.BOOLEAN, new CastModifier("byteint"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.LONG, new CastModifier("numeric(18,0)"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.SHORT, new CastModifier("smallint"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.DOUBLE, new CastModifier("double precision"));
    // $NON-NLS-1$
    convert.addConvert(FunctionModifier.STRING, FunctionModifier.BYTE, new CastModifier("byteint"));
    convert.addConvert(FunctionModifier.TIMESTAMP, FunctionModifier.STRING, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$ //$NON-NLS-2$
            return Arrays.asList("cast(cast(", function.getParameters().get(0), " AS FORMAT 'Y4-MM-DDBHH:MI:SSDS(6)') AS VARCHAR(26))");
        }
    });
    convert.addConvert(FunctionModifier.TIME, FunctionModifier.STRING, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$ //$NON-NLS-2$
            return Arrays.asList("cast(cast(", function.getParameters().get(0), " AS FORMAT 'HH:MI:SS') AS VARCHAR(9))");
        }
    });
    convert.addConvert(FunctionModifier.DATE, FunctionModifier.STRING, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$ //$NON-NLS-2$
            return Arrays.asList("cast(cast(", function.getParameters().get(0), " AS FORMAT 'YYYY-MM-DD') AS VARCHAR(11))");
        }
    });
    // $NON-NLS-1$
    convert.addTypeMapping("varchar(4000)", FunctionModifier.STRING);
    convert.addNumericBooleanConversions();
    registerFunctionModifier(SourceSystemFunctions.CONVERT, convert);
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.SUBSTRING, new AliasModifier("substr"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LOG, new AliasModifier("LN"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LCASE, new AliasModifier("LOWER"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.UCASE, new AliasModifier("UPPER"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LENGTH, new AliasModifier("character_length"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.CURDATE, new AliasModifier("CURRENT_DATE"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.CURTIME, new AliasModifier("CURRENT_TIME"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.YEAR, new ExtractModifier("YEAR"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.MONTH, new ExtractModifier("MONTH"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.DAYOFMONTH, new ExtractModifier("DAY"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.HOUR, new ExtractModifier("HOUR"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.MINUTE, new ExtractModifier("MINUTE"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.SECOND, new ExtractModifier("SECOND"));
    registerFunctionModifier(SourceSystemFunctions.LOCATE, new LocateModifier(this.convert));
    registerFunctionModifier(SourceSystemFunctions.LEFT, new LeftOrRightFunctionModifier(getLanguageFactory(), this.convert));
    registerFunctionModifier(SourceSystemFunctions.RIGHT, new LeftOrRightFunctionModifier(getLanguageFactory(), this.convert));
    registerFunctionModifier(SourceSystemFunctions.COT, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            function.setName(SourceSystemFunctions.TAN);
            return Arrays.asList(getLanguageFactory().createFunction(SourceSystemFunctions.DIVIDE_OP, new Expression[] { new Literal(1, TypeFacility.RUNTIME_TYPES.INTEGER), function }, TypeFacility.RUNTIME_TYPES.DOUBLE));
        }
    });
    registerFunctionModifier(SourceSystemFunctions.LTRIM, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            ArrayList<Object> target = new ArrayList<Object>();
            // $NON-NLS-1$
            target.add("TRIM(LEADING FROM ");
            target.add(function.getParameters().get(0));
            // $NON-NLS-1$
            target.add(")");
            return target;
        }
    });
    registerFunctionModifier(SourceSystemFunctions.RTRIM, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            ArrayList<Object> target = new ArrayList<Object>();
            // $NON-NLS-1$
            target.add("TRIM(TRAILING FROM ");
            target.add(function.getParameters().get(0));
            // $NON-NLS-1$
            target.add(")");
            return target;
        }
    });
    registerFunctionModifier(SourceSystemFunctions.MOD, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$
            return Arrays.asList(function.getParameters().get(0), " MOD ", function.getParameters().get(1));
        }
    });
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "COSH", FLOAT, FLOAT);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "TANH", FLOAT, FLOAT);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "ACOSH", FLOAT, FLOAT);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "ASINH", FLOAT, FLOAT);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "ATANH", FLOAT, FLOAT);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "CHAR2HEXINT", STRING, STRING);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "INDEX", INTEGER, STRING, STRING);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "BYTES", INTEGER, STRING);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "OCTET_LENGTH", INTEGER, STRING);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "HASHAMP", INTEGER, STRING);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "HASHBAKAMP", INTEGER, STRING);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "HASHBUCKET", INTEGER, STRING);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "HASHROW", INTEGER, STRING);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "NULLIFZERO", BIG_DECIMAL, BIG_DECIMAL);
    // $NON-NLS-1$
    addPushDownFunction(TERADATA, "ZEROIFNULL", BIG_DECIMAL, BIG_DECIMAL);
    registerFunctionModifier(SourceSystemFunctions.COT, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            function.setName(SourceSystemFunctions.TAN);
            return Arrays.asList(getLanguageFactory().createFunction(SourceSystemFunctions.DIVIDE_OP, new Expression[] { new Literal(1, TypeFacility.RUNTIME_TYPES.INTEGER), function }, TypeFacility.RUNTIME_TYPES.DOUBLE));
        }
    });
    registerFunctionModifier(SourceSystemFunctions.LTRIM, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$ //$NON-NLS-2$
            return Arrays.asList("TRIM(LEADING FROM ", function.getParameters().get(0), ")");
        }
    });
    registerFunctionModifier(SourceSystemFunctions.RTRIM, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$ //$NON-NLS-2$
            return Arrays.asList("TRIM(TRAILING FROM ", function.getParameters().get(0), ")");
        }
    });
    registerFunctionModifier(SourceSystemFunctions.MOD, new FunctionModifier() {

        @Override
        public List<?> translate(Function function) {
            // $NON-NLS-1$
            return Arrays.asList(function.getParameters().get(0), " MOD ", function.getParameters().get(1));
        }
    });
}

Example 15 with AliasModifier

use of org.teiid.translator.jdbc.AliasModifier in project teiid by teiid.

the class PhoenixExecutionFactory method start.

@Override
public void start() throws TranslatorException {
    super.start();
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.SUBSTRING, new AliasModifier("SUBSTR"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.UCASE, new AliasModifier("UPPER"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LCASE, new AliasModifier("LOWER"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LOCATE, new AliasModifier("INSTR"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.PARSETIMESTAMP, new AliasModifier("TO_TIMESTAMP"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.CURTIME, new AliasModifier("CURRENT_TIME"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LOG, new AliasModifier("LN"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.LOG10, new AliasModifier("LOG"));
    // $NON-NLS-1$
    registerFunctionModifier(SourceSystemFunctions.PARSEBIGDECIMAL, new AliasModifier("TO_NUMBER"));
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "REVERSE", STRING, STRING);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "REGEXP_SUBSTR", STRING, STRING, STRING, INTEGER);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "REGEXP_REPLACE", STRING, STRING, STRING, STRING);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "REGEXP_SPLIT", OBJECT, STRING, STRING);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "TO_DATE", DATE, STRING, STRING, STRING);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "TO_TIME", TIME, STRING, STRING, STRING);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "TIMEZONE_OFFSET", INTEGER, STRING, DATE);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "TIMEZONE_OFFSET", INTEGER, STRING, TIME);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "TIMEZONE_OFFSET", INTEGER, STRING, TIMESTAMP);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "CONVERT_TZ", DATE, DATE, STRING, STRING);
    // $NON-NLS-1$
    addPushDownFunction(PHOENIX, "CONVERT_TZ", TIME, TIME, STRING, STRING);
}