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); }