public List<SqlMoniker> getAllSchemaObjectNames(List<String> names) {
List<SqlMoniker> result;
switch (names.size()) {
case 0:
// looking for schema names
result = new ArrayList<SqlMoniker>();
for (MockSchema schema : schemas.values()) {
result.add(new SqlMonikerImpl(schema.name, SqlMonikerType.Schema));
}
return result;
case 1:
// looking for table names in the given schema
MockSchema schema = schemas.get(names.get(0));
if (schema == null) {
return Collections.emptyList();
}
result = new ArrayList<SqlMoniker>();
for (String tableName : schema.tableNames) {
result.add(new SqlMonikerImpl(tableName, SqlMonikerType.Table));
}
return result;
default:
return Collections.emptyList();
}
}
public SqlRexConvertlet get(SqlCall call) {
SqlRexConvertlet convertlet;
final SqlOperator op = call.getOperator();
// Is there a convertlet for this operator
// (e.g. SqlStdOperatorTable.plusOperator)?
convertlet = (SqlRexConvertlet) map.get(op);
if (convertlet != null) {
return convertlet;
}
// Is there a convertlet for this class of operator
// (e.g. SqlBinaryOperator)?
Class<? extends Object> clazz = op.getClass();
while (clazz != null) {
convertlet = (SqlRexConvertlet) map.get(clazz);
if (convertlet != null) {
return convertlet;
}
clazz = clazz.getSuperclass();
}
// Is there a convertlet for this class of expression
// (e.g. SqlCall)?
clazz = call.getClass();
while (clazz != null) {
convertlet = (SqlRexConvertlet) map.get(clazz);
if (convertlet != null) {
return convertlet;
}
clazz = clazz.getSuperclass();
}
return null;
}
/**
* Registers method if it: a. is public, and b. is named "convertXxx", and c. has a return type of
* "RexNode" or a subtype d. has a 2 parameters with types ConvertletContext and SqlNode (or a
* subtype) respectively.
*/
private void registerNodeTypeMethod(final Method method) {
if (!Modifier.isPublic(method.getModifiers())) {
return;
}
if (!method.getName().startsWith("convert")) {
return;
}
if (!RexNode.class.isAssignableFrom(method.getReturnType())) {
return;
}
final Class[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length != 2) {
return;
}
if (parameterTypes[0] != SqlRexContext.class) {
return;
}
final Class parameterType = parameterTypes[1];
if (!SqlNode.class.isAssignableFrom(parameterType)) {
return;
}
map.put(
parameterType,
new SqlRexConvertlet() {
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
try {
return (RexNode) method.invoke(ReflectiveConvertletTable.this, cx, call);
} catch (IllegalAccessException e) {
throw Util.newInternal(e, "while converting " + call);
} catch (InvocationTargetException e) {
throw Util.newInternal(e, "while converting " + call);
}
}
});
}
/**
* Registers that one operator is an alias for another.
*
* @param alias Operator which is alias
* @param target Operator to translate calls to
*/
protected void addAlias(final SqlOperator alias, final SqlOperator target) {
map.put(
alias,
new SqlRexConvertlet() {
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
Util.permAssert(call.getOperator() == alias, "call to wrong operator");
final SqlCall newCall = target.createCall(SqlParserPos.ZERO, call.getOperandList());
return cx.convertExpression(newCall);
}
});
}
protected void registerSchema(MockSchema schema) {
schemas.put(schema.name, schema);
}
/**
* Registers a convertlet for a given operator instance
*
* @param op Operator instance, say {@link org.eigenbase.sql.fun.SqlStdOperatorTable#MINUS}
* @param convertlet Convertlet
*/
protected void registerOp(SqlOperator op, SqlRexConvertlet convertlet) {
map.put(op, convertlet);
}
