How to use

getItems

method

in

com.facebook.presto.sql.tree.Row

@Override
protected String visitRow(Row node, Void context)
{
  return "ROW (" + Joiner.on(", ").join(node.getItems().stream()
      .map((child) -> process(child, context))
      .collect(toList())) + ")";
}

@Override
protected R visitRow(Row node, C context)
{
  for (Expression expression : node.getItems()) {
    process(expression, context);
  }
  return null;
}

@Override
public Boolean visitRow(Row node, final Void context)
{
  return node.getItems().stream()
      .allMatch(item -> process(item, context));
}

@Override
protected Void visitRow(Row node, Integer indent)
{
  builder.append("ROW(");
  boolean firstItem = true;
  for (Expression item : node.getItems()) {
    if (!firstItem) {
      builder.append(", ");
    }
    process(item, indent);
    firstItem = false;
  }
  builder.append(")");
  return null;
}

  @Override
  protected RowExpression visitRow(Row node, Void context)
  {
    List<RowExpression> arguments = node.getItems().stream()
        .map(value -> process(value, context))
        .collect(toImmutableList());
    Type returnType = getType(node);
    List<Type> argumentTypes = node.getItems().stream()
        .map(this::getType)
        .collect(toImmutableList());
    return call(rowConstructorSignature(returnType, argumentTypes), returnType, arguments);
  }
}

@Override
protected Type visitRow(Row node, StackableAstVisitorContext<Context> context)
{
  List<Type> types = node.getItems().stream()
      .map((child) -> process(child, context))
      .collect(toImmutableList());
  Type type = RowType.anonymous(types);
  return setExpressionType(node, type);
}

@Override
protected RelationPlan visitValues(Values node, Void context)
{
  Scope scope = analysis.getScope(node);
  ImmutableList.Builder<Symbol> outputSymbolsBuilder = ImmutableList.builder();
  for (Field field : scope.getRelationType().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) {
      for (Expression item : ((Row) row).getItems()) {
        Expression expression = Coercer.addCoercions(item, analysis);
        values.add(ExpressionTreeRewriter.rewriteWith(new ParameterRewriter(analysis.getParameters(), analysis), expression));
      }
    }
    else {
      Expression expression = Coercer.addCoercions(row, analysis);
      values.add(ExpressionTreeRewriter.rewriteWith(new ParameterRewriter(analysis.getParameters(), analysis), expression));
    }
    rows.add(values.build());
  }
  ValuesNode valuesNode = new ValuesNode(idAllocator.getNextId(), outputSymbolsBuilder.build(), rows.build());
  return new RelationPlan(valuesNode, scope, outputSymbolsBuilder.build());
}

List<Expression> items = ((Row) row).getItems();
for (int i = 0; i < items.size(); i++) {
  Type expectedType = fieldTypes.get(i);

@Override
protected Object visitRow(Row node, Object context)
{
  RowType rowType = (RowType) type(node);
  List<Type> parameterTypes = rowType.getTypeParameters();
  List<Expression> arguments = node.getItems();
  int cardinality = arguments.size();
  List<Object> values = new ArrayList<>(cardinality);
  for (Expression argument : arguments) {
    values.add(process(argument, context));
  }
  if (hasUnresolvedValue(values)) {
    return new Row(toExpressions(values, parameterTypes));
  }
  else {
    BlockBuilder blockBuilder = new RowBlockBuilder(parameterTypes, null, 1);
    BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry();
    for (int i = 0; i < cardinality; ++i) {
      writeNativeValue(parameterTypes.get(i), singleRowBlockWriter, values.get(i));
    }
    blockBuilder.closeEntry();
    return rowType.getObject(blockBuilder, 0);
  }
}

@Override
protected String visitRow(Row node, Void context) {
  return "ROW (" + Joiner.on(", ").join(node.getItems().stream()
      .map((child) -> process(child, context))
      .collect(toList())) + ")";
}

@Override
protected Void visitRow(Row node, Integer indent) {
  builder.append("ROW(");
  boolean firstItem = true;
  for (Expression item : node.getItems()) {
    if (!firstItem) {
      builder.append(", ");
    }
    process(item, indent);
    firstItem = false;
  }
  builder.append(")");
  return null;
}

@Override
protected R visitRow(Row node, C context)
{
  for (Expression expression : node.getItems()) {
    process(expression, context);
  }
  return null;
}

@Override
protected String visitRow(Row node, Void context)
{
  return "ROW (" + Joiner.on(", ").join(node.getItems().stream()
      .map((child) -> process(child, context))
      .collect(toList())) + ")";
}

@Override
public Boolean visitRow(Row node, final Void context)
{
  return node.getItems().stream()
      .allMatch(item -> process(item, context));
}

@Override
protected R visitRow(Row node, C context)
{
  for (Expression expression : node.getItems()) {
    process(expression, context);
  }
  return null;
}

@Override
protected String visitRow(Row node, Boolean unmangleNames)
{
  return "ROW (" + Joiner.on(", ").join(node.getItems().stream()
      .map((child) -> process(child, unmangleNames))
      .collect(toList())) + ")";
}

@Override
protected String visitRow(Row node, Boolean unmangleNames)
{
  return "ROW (" + Joiner.on(", ").join(node.getItems().stream()
      .map((child) -> process(child, unmangleNames))
      .collect(toList())) + ")";
}

@Override
protected Void visitRow(Row node, Integer indent)
{
  builder.append("ROW(");
  boolean firstItem = true;
  for (Expression item : node.getItems()) {
    if (!firstItem) {
      builder.append(", ");
    }
    process(item, indent);
    firstItem = false;
  }
  builder.append(")");
  return null;
}

@Override
protected Type visitRow(Row node, StackableAstVisitorContext<AnalysisContext> context)
{
  List<Type> types = node.getItems().stream()
      .map((child) -> process(child, context))
      .collect(toImmutableList());
  Type type = new RowType(types, Optional.empty());
  expressionTypes.put(node, type);
  return type;
}

/**
 * Parses the list with values to insert and returns them as Objects
 */
@Override
public List<Object> visitValues(Values values, QueryState state){
  List<Object> result = new ArrayList<Object>();
  
  for(Expression rowExpression : values.getRows()){
    if(rowExpression instanceof Row) {
      Row row = (Row)rowExpression;
      for(Expression rowValue : row.getItems()){
        if(!(rowValue instanceof Literal)) {
          state.addException("Unable to parse non-literal value : "+rowValue);
          return result;
        }
        result.add(getObject((Literal)rowValue));
      }
    }else if (rowExpression instanceof Literal){
      result.add(getObject((Literal)rowExpression));
    }else {
      state.addException("Unknown VALUES type "+rowExpression.getClass()+" encountered");
      return null;
    }
  }
  return result;
}