Пример #1
0
  @Override
  protected RelationPlan visitValues(Values node, Void context) {
    TupleDescriptor descriptor = analysis.getOutputDescriptor(node);
    ImmutableList.Builder<Symbol> outputSymbolsBuilder = ImmutableList.builder();
    for (Field field : descriptor.getVisibleFields()) {
      Symbol symbol = symbolAllocator.newSymbol(field);
      outputSymbolsBuilder.add(symbol);
    }

    ImmutableList.Builder<List<Expression>> rows = ImmutableList.builder();
    for (Expression row : node.getRows()) {
      ImmutableList.Builder<Expression> values = ImmutableList.builder();
      if (row instanceof Row) {
        List<Expression> items = ((Row) row).getItems();
        for (int i = 0; i < items.size(); i++) {
          Expression expression = items.get(i);
          Object constantValue =
              evaluateConstantExpression(expression, analysis.getCoercions(), metadata, session);
          values.add(
              LiteralInterpreter.toExpression(
                  constantValue, descriptor.getFieldByIndex(i).getType()));
        }
      } else {
        Object constantValue =
            evaluateConstantExpression(row, analysis.getCoercions(), metadata, session);
        values.add(
            LiteralInterpreter.toExpression(
                constantValue, descriptor.getFieldByIndex(0).getType()));
      }

      rows.add(values.build());
    }

    ValuesNode valuesNode =
        new ValuesNode(idAllocator.getNextId(), outputSymbolsBuilder.build(), rows.build());
    return new RelationPlan(valuesNode, descriptor, outputSymbolsBuilder.build(), Optional.empty());
  }
Пример #2
0
  private RelationPlan processAndCoerceIfNecessary(Relation node, Void context) {
    Type[] coerceToTypes = analysis.getRelationCoercion(node);

    RelationPlan plan = node.accept(this, context);

    if (coerceToTypes == null) {
      return plan;
    }

    List<Symbol> oldSymbols = plan.getOutputSymbols();
    TupleDescriptor oldDescriptor = plan.getDescriptor().withOnlyVisibleFields();
    verify(coerceToTypes.length == oldSymbols.size());
    ImmutableList.Builder<Symbol> newSymbols = new ImmutableList.Builder<>();
    Field[] newFields = new Field[coerceToTypes.length];
    ImmutableMap.Builder<Symbol, Expression> assignments = new ImmutableMap.Builder<>();
    for (int i = 0; i < coerceToTypes.length; i++) {
      Symbol inputSymbol = oldSymbols.get(i);
      Type inputType = symbolAllocator.getTypes().get(inputSymbol);
      Type outputType = coerceToTypes[i];
      if (outputType != inputType) {
        Cast cast =
            new Cast(
                new QualifiedNameReference(inputSymbol.toQualifiedName()),
                outputType.getTypeSignature().toString());
        Symbol outputSymbol = symbolAllocator.newSymbol(cast, outputType);
        assignments.put(outputSymbol, cast);
        newSymbols.add(outputSymbol);
      } else {
        assignments.put(inputSymbol, new QualifiedNameReference(inputSymbol.toQualifiedName()));
        newSymbols.add(inputSymbol);
      }
      Field oldField = oldDescriptor.getFieldByIndex(i);
      newFields[i] =
          new Field(
              oldField.getRelationAlias(),
              oldField.getName(),
              coerceToTypes[i],
              oldField.isHidden());
    }
    ProjectNode projectNode =
        new ProjectNode(idAllocator.getNextId(), plan.getRoot(), assignments.build());
    return new RelationPlan(
        projectNode, new TupleDescriptor(newFields), newSymbols.build(), plan.getSampleWeight());
  }