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(); } }
/** * Derives the list of column names suitable for NATURAL JOIN. These are the columns that occur * exactly once on each side of the join. * * @param leftRowType Row type of left input to the join * @param rightRowType Row type of right input to the join * @return List of columns that occur once on each side */ public static List<String> deriveNaturalJoinColumnList( RelDataType leftRowType, RelDataType rightRowType) { List<String> naturalColumnNames = new ArrayList<String>(); final List<String> leftNames = leftRowType.getFieldNames(); final List<String> rightNames = rightRowType.getFieldNames(); for (String name : leftNames) { if ((Collections.frequency(leftNames, name) == 1) && (Collections.frequency(rightNames, name) == 1)) { naturalColumnNames.add(name); } } return naturalColumnNames; }
public List<SqlOperator> lookupOperatorOverloads( SqlIdentifier opName, SqlFunctionCategory category, SqlSyntax syntax) { if (syntax != SqlSyntax.Function) { return Collections.emptyList(); } // FIXME: ignoring prefix of opName String name = opName.names[opName.names.length - 1]; List<TableFunction> tableFunctions = rootSchema.getTableFunctions(name); if (tableFunctions.isEmpty()) { return Collections.emptyList(); } return toOps(name, tableFunctions); }
public PreparedResult prepareQueryable(Queryable queryable, RelDataType resultType) { queryString = null; Class runtimeContextClass = Object.class; final Argument[] arguments = {new Argument(connectionVariable, runtimeContextClass, null)}; ClassDeclaration decl = init(arguments); final RelOptQuery query = new RelOptQuery(planner); final RelOptCluster cluster = query.createCluster(env, rexBuilder.getTypeFactory(), rexBuilder); RelNode rootRel = new LixToRelTranslator(cluster).translate(queryable); if (timingTracer != null) { timingTracer.traceTime("end sql2rel"); } final RelDataType jdbcType = makeStruct(rexBuilder.getTypeFactory(), resultType); fieldOrigins = Collections.nCopies(jdbcType.getFieldCount(), null); // Structured type flattening, view expansion, and plugging in // physical storage. rootRel = flattenTypes(rootRel, true); // Trim unused fields. rootRel = trimUnusedFields(rootRel); rootRel = optimize(resultType, rootRel); containsJava = treeContainsJava(rootRel); if (timingTracer != null) { timingTracer.traceTime("end optimization"); } return implement(resultType, rootRel, SqlKind.SELECT, decl, arguments); }
/** Creates a result based on a single relational expression. */ public Result result(SqlNode node, Collection<Clause> clauses, RelNode rel) { final String alias2 = SqlValidatorUtil.getAlias(node, -1); final String alias3 = alias2 != null ? alias2 : "t"; final String alias4 = SqlValidatorUtil.uniquify(alias3, aliasSet, SqlValidatorUtil.EXPR_SUGGESTER); final String alias5 = alias2 == null || !alias2.equals(alias4) ? alias4 : null; return new Result( node, clauses, alias5, Collections.singletonList(Pair.of(alias4, rel.getRowType()))); }
private static List<Expression> simpleList(BlockExpression expression) { Expression simple = Blocks.simple(expression); if (simple instanceof NewExpression) { NewExpression newExpression = (NewExpression) simple; return newExpression.arguments; } else { return Collections.singletonList(simple); } }
public static void getSchemaObjectMonikers( SqlValidatorCatalogReader catalogReader, List<String> names, List<SqlMoniker> hints) { // Assume that the last name is 'dummy' or similar. List<String> subNames = Util.skipLast(names); hints.addAll(catalogReader.getAllSchemaObjectNames(subNames)); // If the name has length 0, try prepending the name of the default // schema. So, the empty name would yield a list of tables in the // default schema, as well as a list of schemas from the above code. if (subNames.size() == 0) { hints.addAll( catalogReader.getAllSchemaObjectNames( Collections.singletonList(catalogReader.getSchemaName()))); } }
public void onMatch(RelOptRuleCall call) { ProjectRel project = (ProjectRel) call.rels[0]; List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(project.getChildExps())); if (reduceExpressions(project, expList)) { call.transformTo( new ProjectRel( project.getCluster(), project.getChild(), expList.toArray(new RexNode[expList.size()]), project.getRowType(), ProjectRel.Flags.Boxed, Collections.<RelCollation>emptyList())); // New plan is absolutely better than old plan. call.getPlanner().setImportance(project, 0.0); } }
<T> PrepareResult<T> prepare_( Context context, String sql, Queryable<T> queryable, Type elementType) { final JavaTypeFactory typeFactory = context.getTypeFactory(); OptiqCatalogReader catalogReader = new OptiqCatalogReader(context.getRootSchema(), typeFactory); final OptiqPreparingStmt preparingStmt = new OptiqPreparingStmt(catalogReader, typeFactory, context.getRootSchema()); preparingStmt.setResultCallingConvention(CallingConvention.ENUMERABLE); final RelDataType x; final PreparedResult preparedResult; if (sql != null) { assert queryable == null; SqlParser parser = new SqlParser(sql); SqlNode sqlNode; try { sqlNode = parser.parseQuery(); } catch (SqlParseException e) { throw new RuntimeException("parse failed", e); } final Schema rootSchema = context.getRootSchema(); SqlValidator validator = new SqlValidatorImpl( new ChainedSqlOperatorTable( Arrays.<SqlOperatorTable>asList( SqlStdOperatorTable.instance(), new MySqlOperatorTable(rootSchema, typeFactory))), catalogReader, typeFactory, SqlConformance.Default) {}; preparedResult = preparingStmt.prepareSql(sqlNode, Object.class, validator, true); x = validator.getValidatedNodeType(sqlNode); } else { assert queryable != null; x = context.getTypeFactory().createType(elementType); preparedResult = preparingStmt.prepareQueryable(queryable, x); } // TODO: parameters final List<Parameter> parameters = Collections.emptyList(); // TODO: column meta data final List<ColumnMetaData> columns = new ArrayList<ColumnMetaData>(); RelDataType jdbcType = makeStruct(typeFactory, x); for (RelDataTypeField field : jdbcType.getFields()) { RelDataType type = field.getType(); SqlTypeName sqlTypeName = type.getSqlTypeName(); columns.add( new ColumnMetaData( columns.size(), false, true, false, false, type.isNullable() ? 1 : 0, true, 0, field.getName(), field.getName(), null, sqlTypeName.allowsPrec() && false ? type.getPrecision() : -1, sqlTypeName.allowsScale() ? type.getScale() : -1, null, null, sqlTypeName.getJdbcOrdinal(), sqlTypeName.getName(), true, false, false, null)); } return new PrepareResult<T>(sql, parameters, columns, (Enumerable<T>) preparedResult.execute()); }
public List<RelCollation> getCollationList() { return Collections.emptyList(); }