@Override
protected void registerSpecificTypeOfOutParameter(
CallableStatement statement, Class<?> runtimeType, int index) throws SQLException {
if (oracleSuppliedDriver) {
if (runtimeType == RefCursorType.class) {
statement.registerOutParameter(index, CURSOR_TYPE);
return;
} else if (runtimeType == TypeFacility.RUNTIME_TYPES.OBJECT) {
// TODO: this is not currently handled and oracle will throw an exception.
// we need additional logic to handle sub types (possibly using the nativeType)
}
}
super.registerSpecificTypeOfOutParameter(statement, runtimeType, index);
}
@Override
public void bindValue(PreparedStatement stmt, Object param, Class<?> paramType, int i)
throws SQLException {
if (Object.class.equals(paramType)) {
// Oracle drive does not support JAVA_OBJECT type
if (param == null) {
stmt.setNull(i, Types.LONGVARBINARY);
} else {
stmt.setObject(i, param);
}
return;
}
if (paramType == FixedCharType.class) {
stmt.setObject(i, param, FIXED_CHAR_TYPE);
return;
}
super.bindValue(stmt, param, paramType, i);
}
@Override
public void start() throws TranslatorException {
super.start();
registerFunctionModifier(
SourceSystemFunctions.UCASE, new AliasModifier("UpperCase")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.LCASE, new AliasModifier("LowerCase")); // $NON-NLS-1$
registerFunctionModifier(JCR_ISCHILDNODE, new IdentifierFunctionModifier());
registerFunctionModifier(JCR_ISDESCENDANTNODE, new IdentifierFunctionModifier());
registerFunctionModifier(JCR_ISSAMENODE, new IdentifierFunctionModifier());
registerFunctionModifier(JCR_REFERENCE, new IdentifierFunctionModifier());
registerFunctionModifier(JCR_CONTAINS, new IdentifierFunctionModifier());
addPushDownFunction(JCR, JCR_ISCHILDNODE, BOOLEAN, STRING, STRING);
addPushDownFunction(JCR, JCR_ISDESCENDANTNODE, BOOLEAN, STRING, STRING);
addPushDownFunction(JCR, JCR_ISSAMENODE, BOOLEAN, STRING, STRING);
addPushDownFunction(JCR, JCR_CONTAINS, BOOLEAN, STRING, STRING);
addPushDownFunction(JCR, JCR_REFERENCE, BOOLEAN, STRING);
LogManager.logTrace(LogConstants.CTX_CONNECTOR, "ModeShape Translator Started"); // $NON-NLS-1$
}
@Override
public void start() throws TranslatorException {
super.start();
this.convert.addTypeMapping("tinyint", FunctionModifier.BYTE); // $NON-NLS-1$
this.convert.addTypeMapping("smallint", FunctionModifier.SHORT); // $NON-NLS-1$
this.convert.addTypeMapping("int", FunctionModifier.INTEGER); // $NON-NLS-1$
this.convert.addTypeMapping(
"bigint", FunctionModifier.BIGINTEGER, FunctionModifier.LONG); // $NON-NLS-1$
this.convert.addTypeMapping("boolean", FunctionModifier.BOOLEAN); // $NON-NLS-1$
this.convert.addTypeMapping("double", FunctionModifier.DOUBLE); // $NON-NLS-1$
this.convert.addTypeMapping("decimal", FunctionModifier.BIGDECIMAL); // $NON-NLS-1$
this.convert.addTypeMapping("float", FunctionModifier.FLOAT); // $NON-NLS-1$
this.convert.addTypeMapping("string", FunctionModifier.STRING); // $NON-NLS-1$
this.convert.addTypeMapping("timestamp", FunctionModifier.TIMESTAMP); // $NON-NLS-1$
this.convert.addTypeMapping("binary", FunctionModifier.BLOB); // $NON-NLS-1$
this.convert.addTypeMapping("decimal", FunctionModifier.BIGDECIMAL); // $NON-NLS-1$
this.convert.addTypeMapping("date", FunctionModifier.DATE); // $NON-NLS-1$
// unsupported types
// FunctionModifier.TIME,
// FunctionModifier.CHAR,
// FunctionModifier.CLOB,
// FunctionModifier.XML
registerFunctionModifier(SourceSystemFunctions.CONVERT, this.convert);
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.CURDATE, new AliasModifier("unix_timestamp")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.IFNULL, new AliasModifier("coalesce")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.MOD,
new ModFunctionModifier(
"%",
getLanguageFactory(),
Arrays.asList(
TypeFacility.RUNTIME_TYPES.BIG_INTEGER,
TypeFacility.RUNTIME_TYPES.BIG_DECIMAL))); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.ARRAY_GET,
new FunctionModifier() {
@Override
public List<?> translate(Function function) {
return Arrays.asList(
function.getParameters().get(0), '[', function.getParameters().get(1), ']');
}
});
addPushDownFunction(HIVE, "lower", STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "upper", STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "positive", INTEGER, DOUBLE); // $NON-NLS-1$
addPushDownFunction(HIVE, "positive", DOUBLE, DOUBLE); // $NON-NLS-1$
addPushDownFunction(HIVE, "negitive", INTEGER, DOUBLE); // $NON-NLS-1$
addPushDownFunction(HIVE, "negitive", DOUBLE, DOUBLE); // $NON-NLS-1$
addPushDownFunction(HIVE, "ln", DOUBLE, DOUBLE); // $NON-NLS-1$
addPushDownFunction(HIVE, "reverse", STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "space", INTEGER, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "split", OBJECT, STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "hex", STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "unhex", STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "bin", STRING, BIG_INTEGER); // $NON-NLS-1$
addPushDownFunction(HIVE, "day", INTEGER, DATE); // $NON-NLS-1$
addPushDownFunction(HIVE, "datediff", INTEGER, STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "date_add", INTEGER, STRING, INTEGER); // $NON-NLS-1$
addPushDownFunction(HIVE, "date_sub", INTEGER, STRING, INTEGER); // $NON-NLS-1$
addPushDownFunction(HIVE, "from_unixtime", STRING, BIG_INTEGER); // $NON-NLS-1$
addPushDownFunction(HIVE, "from_unixtime", STRING, BIG_INTEGER, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "unix_timestamp", BIG_INTEGER, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "unix_timestamp", BIG_INTEGER, STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "to_date", STRING, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "from_utc_timestamp", TIMESTAMP, TIMESTAMP, STRING); // $NON-NLS-1$
addPushDownFunction(HIVE, "to_utc_timestamp", TIMESTAMP, TIMESTAMP, STRING); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "LEAD", OBJECT, OBJECT); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "LEAD", OBJECT, OBJECT, INTEGER); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "LEAD", OBJECT, OBJECT, INTEGER, OBJECT); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "LAG", OBJECT, OBJECT); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "LAG", OBJECT, OBJECT, INTEGER); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "LAG", OBJECT, OBJECT, INTEGER, OBJECT); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "FIRST_VALUE", OBJECT, OBJECT); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "LAST_VALUE", OBJECT, OBJECT); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "PERCENT_RANK", FLOAT); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "CUME_DIST", FLOAT); // $NON-NLS-1$
addAggregatePushDownFunction(HIVE, "NTILE", BIG_INTEGER, INTEGER); // $NON-NLS-1$
}
public void start() throws TranslatorException {
super.start();
registerFunctionModifier(SourceSystemFunctions.CHAR, new AliasModifier("chr")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.LCASE, new AliasModifier("lower")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.UCASE, new AliasModifier("upper")); // $NON-NLS-1$
registerFunctionModifier(SourceSystemFunctions.IFNULL, new AliasModifier("nvl")); // $NON-NLS-1$
registerFunctionModifier(SourceSystemFunctions.LOG, new AliasModifier("ln")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.CEILING, new AliasModifier("ceil")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.LOG10, new Log10FunctionModifier(getLanguageFactory()));
registerFunctionModifier(SourceSystemFunctions.HOUR, new DateAwareExtract());
registerFunctionModifier(SourceSystemFunctions.YEAR, new ExtractFunctionModifier());
registerFunctionModifier(SourceSystemFunctions.MINUTE, new DateAwareExtract());
registerFunctionModifier(SourceSystemFunctions.SECOND, new DateAwareExtract());
registerFunctionModifier(SourceSystemFunctions.MONTH, new ExtractFunctionModifier());
registerFunctionModifier(SourceSystemFunctions.DAYOFMONTH, new ExtractFunctionModifier());
registerFunctionModifier(
SourceSystemFunctions.MONTHNAME,
new MonthOrDayNameFunctionModifier(getLanguageFactory(), "Month")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.DAYNAME,
new MonthOrDayNameFunctionModifier(getLanguageFactory(), "Day")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.WEEK, new DayWeekQuarterFunctionModifier("WW")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.QUARTER, new DayWeekQuarterFunctionModifier("Q")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.DAYOFWEEK, new DayWeekQuarterFunctionModifier("D")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.DAYOFYEAR, new DayWeekQuarterFunctionModifier("DDD")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.LOCATE,
new LocateFunctionModifier(getLanguageFactory(), "INSTR", true)); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.SUBSTRING, new AliasModifier("substr")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.LEFT, new LeftOrRightFunctionModifier(getLanguageFactory()));
registerFunctionModifier(
SourceSystemFunctions.RIGHT, new LeftOrRightFunctionModifier(getLanguageFactory()));
registerFunctionModifier(
SourceSystemFunctions.CONCAT, new ConcatFunctionModifier(getLanguageFactory()));
registerFunctionModifier(SourceSystemFunctions.CONCAT2, new AliasModifier("||")); // $NON-NLS-1$
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));
}
});
// spatial functions
registerFunctionModifier(OracleExecutionFactory.RELATE, new OracleSpatialFunctionModifier());
registerFunctionModifier(
OracleExecutionFactory.NEAREST_NEIGHBOR, new OracleSpatialFunctionModifier());
registerFunctionModifier(OracleExecutionFactory.FILTER, new OracleSpatialFunctionModifier());
registerFunctionModifier(
OracleExecutionFactory.WITHIN_DISTANCE, new OracleSpatialFunctionModifier());
registerFunctionModifier(
SourceSystemFunctions.PARSETIMESTAMP,
new OracleFormatFunctionModifier("TO_TIMESTAMP(")); // $NON-NLS-1$
registerFunctionModifier(
SourceSystemFunctions.FORMATTIMESTAMP,
new OracleFormatFunctionModifier("TO_CHAR(")); // $NON-NLS-1$
// add in type conversion
ConvertModifier convertModifier = new ConvertModifier();
convertModifier.addTypeMapping("char(1)", FunctionModifier.CHAR); // $NON-NLS-1$
convertModifier.addTypeMapping(
"date", FunctionModifier.DATE, FunctionModifier.TIME); // $NON-NLS-1$
convertModifier.addTypeMapping("timestamp", FunctionModifier.TIMESTAMP); // $NON-NLS-1$
convertModifier.addConvert(
FunctionModifier.TIMESTAMP,
FunctionModifier.TIME,
new FunctionModifier() {
@Override
public List<?> translate(Function function) {
return Arrays.asList(
"case when ",
function.getParameters().get(0),
" is null then null else to_date('1970-01-01 ' || to_char(",
function.getParameters().get(0),
", 'HH24:MI:SS'), 'YYYY-MM-DD HH24:MI:SS') end"); //$NON-NLS-1$ //$NON-NLS-2$
// //$NON-NLS-3$
}
});
convertModifier.addConvert(
FunctionModifier.TIMESTAMP,
FunctionModifier.DATE,
new FunctionModifier() {
@Override
public List<?> translate(Function function) {
return Arrays.asList(
"trunc(cast(",
function.getParameters().get(0),
" AS date))"); //$NON-NLS-1$ //$NON-NLS-2$
}
});
convertModifier.addConvert(
FunctionModifier.DATE,
FunctionModifier.STRING,
new ConvertModifier.FormatModifier("to_char", DATE_FORMAT)); // $NON-NLS-1$
convertModifier.addConvert(
FunctionModifier.TIME,
FunctionModifier.STRING,
new ConvertModifier.FormatModifier("to_char", TIME_FORMAT)); // $NON-NLS-1$
convertModifier.addConvert(
FunctionModifier.TIMESTAMP,
FunctionModifier.STRING,
new FunctionModifier() {
@Override
public List<?> translate(Function function) {
// if column and type is date, just use date format
Expression ex = function.getParameters().get(0);
String format = TIMESTAMP_FORMAT;
if (ex instanceof ColumnReference
&& "date"
.equalsIgnoreCase(
((ColumnReference) ex)
.getMetadataObject()
.getNativeType())) { //$NON-NLS-1$
format = DATETIME_FORMAT;
} else if (!(ex instanceof Literal) && !(ex instanceof Function)) {
// this isn't needed in every case, but it's simpler than inspecting the expression
// more
ex =
ConvertModifier.createConvertFunction(
getLanguageFactory(),
function.getParameters().get(0),
TypeFacility.RUNTIME_NAMES.TIMESTAMP);
}
return Arrays.asList(
"to_char(", ex, ", '", format, "')"); // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
});
convertModifier.addConvert(
FunctionModifier.STRING,
FunctionModifier.DATE,
new ConvertModifier.FormatModifier("to_date", DATE_FORMAT)); // $NON-NLS-1$
convertModifier.addConvert(
FunctionModifier.STRING,
FunctionModifier.TIME,
new ConvertModifier.FormatModifier("to_date", TIME_FORMAT)); // $NON-NLS-1$
convertModifier.addConvert(
FunctionModifier.STRING,
FunctionModifier.TIMESTAMP,
new ConvertModifier.FormatModifier("to_timestamp", TIMESTAMP_FORMAT)); // $NON-NLS-1$
convertModifier.addTypeConversion(
new ConvertModifier.FormatModifier("to_char"), FunctionModifier.STRING); // $NON-NLS-1$
// NOTE: numeric handling in Oracle is split only between integral vs. floating/decimal types
convertModifier.addTypeConversion(
new ConvertModifier.FormatModifier("to_number"), // $NON-NLS-1$
FunctionModifier.FLOAT,
FunctionModifier.DOUBLE,
FunctionModifier.BIGDECIMAL);
convertModifier.addTypeConversion(
new FunctionModifier() {
@Override
public List<?> translate(Function function) {
if (Number.class.isAssignableFrom(function.getParameters().get(0).getType())) {
return Arrays.asList(
"trunc(", function.getParameters().get(0), ")"); // $NON-NLS-1$ //$NON-NLS-2$
}
return Arrays.asList(
"trunc(to_number(",
function.getParameters().get(0),
"))"); //$NON-NLS-1$ //$NON-NLS-2$
}
},
FunctionModifier.BYTE,
FunctionModifier.SHORT,
FunctionModifier.INTEGER,
FunctionModifier.LONG,
FunctionModifier.BIGINTEGER);
convertModifier.addNumericBooleanConversions();
convertModifier.setWideningNumericImplicit(true);
registerFunctionModifier(SourceSystemFunctions.CONVERT, convertModifier);
addPushDownFunction(ORACLE_SDO, RELATE, STRING, STRING, STRING, STRING);
addPushDownFunction(ORACLE_SDO, RELATE, STRING, OBJECT, OBJECT, STRING);
addPushDownFunction(ORACLE_SDO, RELATE, STRING, STRING, OBJECT, STRING);
addPushDownFunction(ORACLE_SDO, RELATE, STRING, OBJECT, STRING, STRING);
addPushDownFunction(ORACLE_SDO, NEAREST_NEIGHBOR, STRING, STRING, OBJECT, STRING, INTEGER);
addPushDownFunction(ORACLE_SDO, NEAREST_NEIGHBOR, STRING, OBJECT, OBJECT, STRING, INTEGER);
addPushDownFunction(ORACLE_SDO, NEAREST_NEIGHBOR, STRING, OBJECT, STRING, STRING, INTEGER);
addPushDownFunction(ORACLE_SDO, NEAREST_NEIGHBOR_DISTANCE, INTEGER, INTEGER);
addPushDownFunction(ORACLE_SDO, WITHIN_DISTANCE, STRING, OBJECT, OBJECT, STRING);
addPushDownFunction(ORACLE_SDO, WITHIN_DISTANCE, STRING, STRING, OBJECT, STRING);
addPushDownFunction(ORACLE_SDO, WITHIN_DISTANCE, STRING, OBJECT, STRING, STRING);
addPushDownFunction(ORACLE_SDO, FILTER, STRING, OBJECT, STRING, STRING);
addPushDownFunction(ORACLE_SDO, FILTER, STRING, OBJECT, OBJECT, STRING);
addPushDownFunction(ORACLE_SDO, FILTER, STRING, STRING, OBJECT, STRING);
}