/** * It allows a column visitor to traverse all columns in a schema in a depth-first order. * @param schema * @param function */ public static void visitSchema(Schema schema, ColumnVisitor function) { for(Column col : schema.getRootColumns()) { visitInDepthFirstOrder(0, NestedPathUtil.ROOT_PATH, function, col); } }
public synchronized void addColumns(Schema schema) { for(Column column : schema.getRootColumns()) { addColumn(column); } }
/** * It allows a column visitor to traverse all columns in a schema in a depth-first order. * @param schema * @param function */ public static void visitSchema(Schema schema, ColumnVisitor function) { for(Column col : schema.getRootColumns()) { visitInDepthFirstOrder(0, NestedPathUtil.ROOT_PATH, function, col); } }
public static List<ColumnStats> emptyColumnStats(Schema schema) { List<ColumnStats> stats = new ArrayList<>(schema.size()); for (Column column : schema.getRootColumns()) { stats.add(new ColumnStats(column)); } return stats; } }
public static List<ColumnStats> emptyColumnStats(Schema schema) { List<ColumnStats> stats = new ArrayList<>(schema.size()); for (Column column : schema.getRootColumns()) { stats.add(new ColumnStats(column)); } return stats; } }
public static int[] getTargetIds(Schema inSchema, Schema outSchema) { int[] targetIds = new int[outSchema.size()]; int i = 0; for (Column target : outSchema.getRootColumns()) { targetIds[i] = inSchema.getColumnId(target.getQualifiedName()); i++; } return targetIds; }
public static int[] getTargetIds(Schema inSchema, Schema outSchema) { int[] targetIds = new int[outSchema.size()]; int i = 0; for (Column target : outSchema.getRootColumns()) { targetIds[i] = inSchema.getColumnId(target.getQualifiedName()); i++; } return targetIds; }
public static Type convert(TypeDesc type) { if (type.getDataType().getType() == TajoDataTypes.Type.RECORD) { ImmutableList.Builder<Field> fields = ImmutableList.builder(); for (Column c : type.getNestedSchema().getRootColumns()) { fields.add(FieldConverter.convert(c)); } return Record(fields.build()); } else { return convert(type.dataType); } }
public static int[] getTargetIds(Schema inSchema, Schema outSchema) { int[] targetIds = new int[outSchema.size()]; int i = 0; for (Column target : outSchema.getRootColumns()) { targetIds[i] = inSchema.getColumnId(target.getQualifiedName()); i++; } return targetIds; }
public static int[] getTargetIds(Schema inSchema, Schema outSchema) { int[] targetIds = new int[outSchema.size()]; int i = 0; for (Column target : outSchema.getRootColumns()) { targetIds[i] = inSchema.getColumnId(target.getQualifiedName()); i++; } return targetIds; }
private static Schema getNaturalJoinSchema(LogicalNode left, LogicalNode right) { SchemaBuilder joinSchema = SchemaBuilder.uniqueNameBuilder(); joinSchema.addAll(left.getOutSchema().getRootColumns()); joinSchema.addAll(right.getOutSchema().getRootColumns()); return joinSchema.build(); }
private static Schema mergeSubSchemas(Schema originalSchema, Schema subSchema, List<Target> targets, EvalNode qual) { Set<Column> qualAndTargets = new HashSet<>(); qualAndTargets.addAll(EvalTreeUtil.findUniqueColumns(qual)); for (Target target : targets) { qualAndTargets.addAll(EvalTreeUtil.findUniqueColumns(target.getEvalTree())); } SchemaBuilder mergedSchema = SchemaBuilder.builder(); for (Column column : originalSchema.getRootColumns()) { if (subSchema.contains(column) || qualAndTargets.contains(column)) { mergedSchema.add(column); } } return mergedSchema.build(); }
private static Schema mergeSubSchemas(Schema originalSchema, Schema subSchema, Target[] targets, EvalNode qual) { Schema mergedSchema = new Schema(); Set<Column> qualAndTargets = TUtil.newHashSet(); qualAndTargets.addAll(EvalTreeUtil.findUniqueColumns(qual)); for (Target target : targets) { qualAndTargets.addAll(EvalTreeUtil.findUniqueColumns(target.getEvalTree())); } for (Column column : originalSchema.getRootColumns()) { if (subSchema.contains(column) || qualAndTargets.contains(column)) { mergedSchema.addColumn(column); } } return mergedSchema; }
public static TypeDescription convertSchema(Schema schema) { TypeDescription description = TypeDescription.createStruct(); for (Column eachColumn : schema.getRootColumns()) { description.addField(eachColumn.getQualifiedName(), convertTypeInfo(eachColumn.getTypeDesc())); } return description; }
public static Schema getQualifiedLogicalSchema(TableDesc tableDesc, String tableName) { Schema logicalSchema = SchemaBuilder.builder().addAll(tableDesc.getLogicalSchema().getRootColumns()).build(); if (tableName != null) { logicalSchema.setQualifier(tableName); } return logicalSchema; }
/** * Get common columns to be used as join keys of natural joins. */ public static Schema getNaturalJoinColumns(Schema left, Schema right) { SchemaBuilder common = SchemaBuilder.builder(); Set<String> commonNames = new HashSet<>(); for (Column outer : left.getRootColumns()) { if (!commonNames.contains(outer.getSimpleName()) && right.containsByName(outer.getSimpleName())) { common.add(new Column(outer.getSimpleName(), outer.getDataType())); commonNames.add(outer.getSimpleName()); } } return common.build(); }
public static TypeDescription convertSchema(Schema schema) { TypeDescription description = TypeDescription.createStruct(); for (Column eachColumn : schema.getRootColumns()) { description.addField(eachColumn.getQualifiedName(), convertTypeInfo(eachColumn.getTypeDesc())); } return description; }
/** * Get common columns to be used as join keys of natural joins. */ public static Schema getNaturalJoinColumns(Schema left, Schema right) { Schema common = new Schema(); for (Column outer : left.getRootColumns()) { if (!common.containsByName(outer.getSimpleName()) && right.containsByName(outer.getSimpleName())) { common.addColumn(new Column(outer.getSimpleName(), outer.getDataType())); } } return common; }
@Test public final void testAlias2() throws TajoException { QueryContext qc = createQueryContext(); Expr expr = sqlAnalyzer.parse(ALIAS[1]); LogicalNode plan = planner.createPlan(qc, expr).getRootBlock().getRoot(); LogicalRootNode root = (LogicalRootNode) plan; Schema finalSchema = root.getOutSchema(); Iterator<Column> it = finalSchema.getRootColumns().iterator(); Column col = it.next(); assertEquals("id", col.getSimpleName()); col = it.next(); assertEquals("total", col.getSimpleName()); }
public void init(TableDesc desc, String alias) { this.tableDesc = desc; this.alias = alias; if (!IdentifierUtil.isFQTableName(this.tableDesc.getName())) { throw new IllegalArgumentException("the name in TableDesc must be qualified, but it is \"" + desc.getName() + "\""); } String databaseName = IdentifierUtil.extractQualifier(this.tableDesc.getName()); String qualifiedAlias = IdentifierUtil.buildFQName(databaseName, alias); this.setInSchema(tableDesc.getSchema()); this.getInSchema().setQualifier(qualifiedAlias); this.setOutSchema(SchemaBuilder.builder().addAll(getInSchema().getRootColumns()).build()); logicalSchema = SchemaUtil.getQualifiedLogicalSchema(tableDesc, qualifiedAlias); }