How to use

GroupingOperation

in

io.prestosql.sql.tree

@Override
public Node visitGroupingOperation(SqlBaseParser.GroupingOperationContext context)
{
  List<QualifiedName> arguments = context.qualifiedName().stream()
      .map(this::getQualifiedName)
      .collect(toList());
  return new GroupingOperation(Optional.of(getLocation(context)), arguments);
}

@Override
protected R visitGroupingOperation(GroupingOperation node, C context)
{
  for (Expression columnArgument : node.getGroupingColumns()) {
    process(columnArgument, context);
  }
  return null;
}

public String visitGroupingOperation(GroupingOperation node, Void context)
{
  return "GROUPING (" + joinExpressions(node.getGroupingColumns()) + ")";
}

@Override
public Node visitGroupingOperation(SqlBaseParser.GroupingOperationContext context)
{
  List<QualifiedName> arguments = context.qualifiedName().stream()
      .map(this::getQualifiedName)
      .collect(toList());
  return new GroupingOperation(Optional.of(getLocation(context)), arguments);
}

@Override
protected R visitGroupingOperation(GroupingOperation node, C context)
{
  for (Expression columnArgument : node.getGroupingColumns()) {
    process(columnArgument, context);
  }
  return null;
}

DereferenceExpression.from(QualifiedName.of("a")),
DereferenceExpression.from(QualifiedName.of("b")),
new GroupingOperation(
    Optional.empty(),
    ImmutableList.of(QualifiedName.of("a"), QualifiedName.of("b")))),

public String visitGroupingOperation(GroupingOperation node, Void context)
{
  return "GROUPING (" + joinExpressions(node.getGroupingColumns()) + ")";
}

@Override
public Type visitGroupingOperation(GroupingOperation node, StackableAstVisitorContext<Context> context)
{
  if (node.getGroupingColumns().size() > MAX_NUMBER_GROUPING_ARGUMENTS_BIGINT) {
    throw new SemanticException(INVALID_PROCEDURE_ARGUMENTS, node, String.format("GROUPING supports up to %d column arguments", MAX_NUMBER_GROUPING_ARGUMENTS_BIGINT));
  }
  for (Expression columnArgument : node.getGroupingColumns()) {
    process(columnArgument, context);
  }
  if (node.getGroupingColumns().size() <= MAX_NUMBER_GROUPING_ARGUMENTS_INTEGER) {
    return setExpressionType(node, INTEGER);
  }
  else {
    return setExpressionType(node, BIGINT);
  }
}

@Override
public Type visitGroupingOperation(GroupingOperation node, StackableAstVisitorContext<Context> context)
{
  if (node.getGroupingColumns().size() > MAX_NUMBER_GROUPING_ARGUMENTS_BIGINT) {
    throw new SemanticException(INVALID_PROCEDURE_ARGUMENTS, node, String.format("GROUPING supports up to %d column arguments", MAX_NUMBER_GROUPING_ARGUMENTS_BIGINT));
  }
  for (Expression columnArgument : node.getGroupingColumns()) {
    process(columnArgument, context);
  }
  if (node.getGroupingColumns().size() <= MAX_NUMBER_GROUPING_ARGUMENTS_INTEGER) {
    return setExpressionType(node, INTEGER);
  }
  else {
    return setExpressionType(node, BIGINT);
  }
}

public Boolean visitGroupingOperation(GroupingOperation node, Void context)
{
  // ensure that no output fields are referenced from ORDER BY clause
  if (orderByScope.isPresent()) {
    node.getGroupingColumns().forEach(groupingColumn -> verifyNoOrderByReferencesToOutputColumns(
        groupingColumn,
        REFERENCE_TO_OUTPUT_ATTRIBUTE_WITHIN_ORDER_BY_GROUPING,
        "Invalid reference to output of SELECT clause from grouping() expression in ORDER BY"));
  }
  Optional<Expression> argumentNotInGroupBy = node.getGroupingColumns().stream()
      .filter(argument -> !columnReferences.containsKey(NodeRef.of(argument)) || !isGroupingKey(argument))
      .findAny();
  if (argumentNotInGroupBy.isPresent()) {
    throw new SemanticException(
        INVALID_PROCEDURE_ARGUMENTS,
        node,
        "The arguments to GROUPING() must be expressions referenced by the GROUP BY at the associated query level. Mismatch due to %s.",
        argumentNotInGroupBy.get());
  }
  return true;
}

public Boolean visitGroupingOperation(GroupingOperation node, Void context)
{
  // ensure that no output fields are referenced from ORDER BY clause
  if (orderByScope.isPresent()) {
    node.getGroupingColumns().forEach(groupingColumn -> verifyNoOrderByReferencesToOutputColumns(
        groupingColumn,
        REFERENCE_TO_OUTPUT_ATTRIBUTE_WITHIN_ORDER_BY_GROUPING,
        "Invalid reference to output of SELECT clause from grouping() expression in ORDER BY"));
  }
  Optional<Expression> argumentNotInGroupBy = node.getGroupingColumns().stream()
      .filter(argument -> !columnReferences.containsKey(NodeRef.of(argument)) || !isGroupingKey(argument))
      .findAny();
  if (argumentNotInGroupBy.isPresent()) {
    throw new SemanticException(
        INVALID_PROCEDURE_ARGUMENTS,
        node,
        "The arguments to GROUPING() must be expressions referenced by the GROUP BY at the associated query level. Mismatch due to %s.",
        argumentNotInGroupBy.get());
  }
  return true;
}

public static Expression rewriteGroupingOperation(GroupingOperation expression, List<Set<Integer>> groupingSets, Map<NodeRef<Expression>, FieldId> columnReferenceFields, Optional<Symbol> groupIdSymbol)
{
  requireNonNull(groupIdSymbol, "groupIdSymbol is null");
  // No GroupIdNode and a GROUPING() operation imply a single grouping, which
  // means that any columns specified as arguments to GROUPING() will be included
  // in the group and none of them will be aggregated over. Hence, re-write the
  // GroupingOperation to a constant literal of 0.
  // See SQL:2011:4.16.2 and SQL:2011:6.9.10.
  if (groupingSets.size() == 1) {
    return new LongLiteral("0");
  }
  else {
    checkState(groupIdSymbol.isPresent(), "groupId symbol is missing");
    RelationId relationId = columnReferenceFields.get(NodeRef.of(expression.getGroupingColumns().get(0))).getRelationId();
    List<Integer> columns = expression.getGroupingColumns().stream()
        .map(NodeRef::of)
        .peek(groupingColumn -> checkState(columnReferenceFields.containsKey(groupingColumn), "the grouping column is not in the columnReferencesField map"))
        .map(columnReferenceFields::get)
        .map(fieldId -> translateFieldToInteger(fieldId, relationId))
        .collect(toImmutableList());
    List<Expression> groupingResults = groupingSets.stream()
        .map(groupingSet -> String.valueOf(calculateGrouping(groupingSet, columns)))
        .map(LongLiteral::new)
        .collect(toImmutableList());
    // It is necessary to add a 1 to the groupId because the underlying array is indexed starting at 1
    return new SubscriptExpression(
        new ArrayConstructor(groupingResults),
        new ArithmeticBinaryExpression(ADD, groupIdSymbol.get().toSymbolReference(), new GenericLiteral("BIGINT", "1")));
  }
}

public static Expression rewriteGroupingOperation(GroupingOperation expression, List<Set<Integer>> groupingSets, Map<NodeRef<Expression>, FieldId> columnReferenceFields, Optional<Symbol> groupIdSymbol)
{
  requireNonNull(groupIdSymbol, "groupIdSymbol is null");
  // No GroupIdNode and a GROUPING() operation imply a single grouping, which
  // means that any columns specified as arguments to GROUPING() will be included
  // in the group and none of them will be aggregated over. Hence, re-write the
  // GroupingOperation to a constant literal of 0.
  // See SQL:2011:4.16.2 and SQL:2011:6.9.10.
  if (groupingSets.size() == 1) {
    return new LongLiteral("0");
  }
  else {
    checkState(groupIdSymbol.isPresent(), "groupId symbol is missing");
    RelationId relationId = columnReferenceFields.get(NodeRef.of(expression.getGroupingColumns().get(0))).getRelationId();
    List<Integer> columns = expression.getGroupingColumns().stream()
        .map(NodeRef::of)
        .peek(groupingColumn -> checkState(columnReferenceFields.containsKey(groupingColumn), "the grouping column is not in the columnReferencesField map"))
        .map(columnReferenceFields::get)
        .map(fieldId -> translateFieldToInteger(fieldId, relationId))
        .collect(toImmutableList());
    List<Expression> groupingResults = groupingSets.stream()
        .map(groupingSet -> String.valueOf(calculateGrouping(groupingSet, columns)))
        .map(LongLiteral::new)
        .collect(toImmutableList());
    // It is necessary to add a 1 to the groupId because the underlying array is indexed starting at 1
    return new SubscriptExpression(
        new ArrayConstructor(groupingResults),
        new ArithmeticBinaryExpression(ADD, groupIdSymbol.get().toSymbolReference(), new GenericLiteral("BIGINT", "1")));
  }
}