How to use

OrderByColumnSpec

in

org.apache.druid.query.groupby.orderby

public static OrderByColumnSpec asc(String dimension)
{
 return new OrderByColumnSpec(dimension, Direction.ASCENDING, null);
}

final OrderByColumnSpec limitColumn;
if (limitSpec.getColumns().isEmpty()) {
 limitColumn = new OrderByColumnSpec(
   dimensionSpec.getOutputName(),
   OrderByColumnSpec.Direction.ASCENDING,
if (limitColumn.getDimension().equals(dimensionSpec.getOutputName())) {
   limitColumn.getDimensionComparator()
 );
 topNMetricSpec = limitColumn.getDirection() == OrderByColumnSpec.Direction.ASCENDING
          ? baseMetricSpec
          : new InvertedTopNMetricSpec(baseMetricSpec);
} else if (plannerContext.getPlannerConfig().isUseApproximateTopN()) {
 final NumericTopNMetricSpec baseMetricSpec = new NumericTopNMetricSpec(limitColumn.getDimension());
 topNMetricSpec = limitColumn.getDirection() == OrderByColumnSpec.Direction.ASCENDING
          ? new InvertedTopNMetricSpec(baseMetricSpec)
          : baseMetricSpec;

 @Override
 public OrderByColumnSpec apply(@Nullable String input)
 {
  return asc(input);
 }
}

public static StringComparator getComparatorForDimName(DefaultLimitSpec limitSpec, String dimName)
{
 final OrderByColumnSpec orderBy = OrderByColumnSpec.getOrderByForDimName(limitSpec.getColumns(), dimName);
 if (orderBy == null) {
  return null;
 }
 return orderBy.getDimensionComparator();
}

final boolean needsReverse = orderSpec.getDirection() != OrderByColumnSpec.Direction.ASCENDING;
int dimIndex = OrderByColumnSpec.getDimIndexForOrderBy(orderSpec, dimensions);
if (dimIndex >= 0) {
 fieldIndices.add(dimIndex);
 final ValueType type = dimensions.get(dimIndex).getOutputType();
 isNumericField.add(ValueType.isNumeric(type));
 comparators.add(orderSpec.getDimensionComparator());
} else {
 int aggIndex = OrderByColumnSpec.getAggIndexForOrderBy(orderSpec, Arrays.asList(aggregatorFactories));
 if (aggIndex >= 0) {
  fieldIndices.add(aggIndex);
  final String typeName = aggregatorFactories[aggIndex].getTypeName();
  isNumericField.add(ValueType.isNumeric(ValueType.fromString(typeName)));
  comparators.add(orderSpec.getDimensionComparator());

boolean needsReverse = orderSpec.getDirection() != OrderByColumnSpec.Direction.ASCENDING;
int dimIndex = OrderByColumnSpec.getDimIndexForOrderBy(orderSpec, dimensions);
if (dimIndex >= 0) {
 DimensionSpec dim = dimensions.get(dimIndex);
 final ValueType type = dimensions.get(dimIndex).getOutputType();
 dimensionTypes.add(type);
 comparators.add(orderSpec.getDimensionComparator());

final OrderByColumnSpec columnSpec = columns.get(i);
if (aggAndPostAggNames.contains(columnSpec.getDimension())) {
 sortingNeeded = true;
 break;
if (columnSpec.getDirection() != OrderByColumnSpec.Direction.ASCENDING
  || !columnSpec.getDimensionComparator().equals(naturalComparator)
  || !columnSpec.getDimension().equals(dimensions.get(i).getOutputName())) {
 sortingNeeded = true;
 break;

} else if (limitSpec.getColumns().size() == 1) {
 final OrderByColumnSpec orderBy = Iterables.getOnlyElement(limitSpec.getColumns());
 if (!orderBy.getDimension().equals(ColumnHolder.TIME_COLUMN_NAME)) {
 descending = orderBy.getDirection() == OrderByColumnSpec.Direction.DESCENDING;
} else {

public static int getAggIndexForOrderBy(OrderByColumnSpec orderSpec, List<AggregatorFactory> aggregatorFactories)
{
 int i = 0;
 for (AggregatorFactory agg : aggregatorFactories) {
  if (orderSpec.getDimension().equals((agg.getName()))) {
   return i;
  }
  i++;
 }
 return -1;
}

new DefaultLimitSpec(OrderByColumnSpec.ascending("idx"), null),
new DefaultLimitSpec(OrderByColumnSpec.ascending("rows", "idx"), null),
new DefaultLimitSpec(OrderByColumnSpec.descending("idx"), null),
new DefaultLimitSpec(OrderByColumnSpec.descending("rows", "idx"), null),
};

String columnName = columnSpec.getDimension();
Ordering<Row> nextOrdering = null;
 nextOrdering = metricOrdering(columnName, aggregatorsMap.get(columnName).getComparator());
} else if (dimensionsMap.containsKey(columnName)) {
 nextOrdering = dimensionOrdering(columnName, columnSpec.getDimensionComparator());
if (columnSpec.getDirection() == OrderByColumnSpec.Direction.DESCENDING) {
 nextOrdering = nextOrdering.reverse();

boolean needsReverse;
for (OrderByColumnSpec orderSpec : limitSpec.getColumns()) {
 needsReverse = orderSpec.getDirection() != OrderByColumnSpec.Direction.ASCENDING;
 int dimIndex = OrderByColumnSpec.getDimIndexForOrderBy(orderSpec, dimensions);
 if (dimIndex >= 0) {
  RowBasedKeySerdeHelper serdeHelper = serdeHelpers[dimIndex];
  needsReverses.add(needsReverse);
 } else {
  int aggIndex = OrderByColumnSpec.getAggIndexForOrderBy(orderSpec, Arrays.asList(aggregatorFactories));
  if (aggIndex >= 0) {
   final RowBasedKeySerdeHelper serdeHelper;
   final StringComparator stringComparator = orderSpec.getDimensionComparator();
   final String typeName = aggregatorFactories[aggIndex].getTypeName();
   final int aggOffset = aggregatorOffsets[aggIndex] - Integer.BYTES;

if (firstOrderBy.getDimension().equals(dimensionExpression.getOutputName())) {
 descending = firstOrderBy.getDirection() == OrderByColumnSpec.Direction.DESCENDING;
} else {

boolean needsReverse = orderSpec.getDirection() != OrderByColumnSpec.Direction.ASCENDING;
int dimIndex = OrderByColumnSpec.getDimIndexForOrderBy(orderSpec, dimensions);
if (dimIndex >= 0) {
 DimensionSpec dim = dimensions.get(dimIndex);
 final ValueType type = dimensions.get(dimIndex).getOutputType();
 dimensionTypes.add(type);
 comparators.add(orderSpec.getDimensionComparator());

public static int getPostAggIndexForOrderBy(OrderByColumnSpec orderSpec, List<PostAggregator> postAggs)
{
 int i = 0;
 for (PostAggregator postAgg : postAggs) {
  if (orderSpec.getDimension().equals((postAgg.getName()))) {
   return i;
  }
  i++;
 }
 return -1;
}

public static StringComparator getComparatorForDimName(DefaultLimitSpec limitSpec, String dimName)
{
 final OrderByColumnSpec orderBy = OrderByColumnSpec.getOrderByForDimName(limitSpec.getColumns(), dimName);
 if (orderBy == null) {
  return null;
 }
 return orderBy.getDimensionComparator();
}

public static OrderByColumnSpec desc(String dimension)
{
 return new OrderByColumnSpec(dimension, Direction.DESCENDING, null);
}

final OrderByColumnSpec limitColumn;
if (limitSpec.getColumns().isEmpty()) {
 limitColumn = new OrderByColumnSpec(
   dimensionSpec.getOutputName(),
   OrderByColumnSpec.Direction.ASCENDING,
if (limitColumn.getDimension().equals(dimensionSpec.getOutputName())) {
   limitColumn.getDimensionComparator()
 );
 topNMetricSpec = limitColumn.getDirection() == OrderByColumnSpec.Direction.ASCENDING
          ? baseMetricSpec
          : new InvertedTopNMetricSpec(baseMetricSpec);
} else if (plannerContext.getPlannerConfig().isUseApproximateTopN()) {
 final NumericTopNMetricSpec baseMetricSpec = new NumericTopNMetricSpec(limitColumn.getDimension());
 topNMetricSpec = limitColumn.getDirection() == OrderByColumnSpec.Direction.ASCENDING
          ? new InvertedTopNMetricSpec(baseMetricSpec)
          : baseMetricSpec;

final OrderByColumnSpec columnSpec = columns.get(i);
if (aggAndPostAggNames.contains(columnSpec.getDimension())) {
 sortingNeeded = true;
 break;
if (columnSpec.getDirection() != OrderByColumnSpec.Direction.ASCENDING
  || !columnSpec.getDimensionComparator().equals(naturalComparator)
  || !columnSpec.getDimension().equals(dimensions.get(i).getOutputName())) {
 sortingNeeded = true;
 break;

final boolean needsReverse = orderSpec.getDirection() != OrderByColumnSpec.Direction.ASCENDING;
int dimIndex = OrderByColumnSpec.getDimIndexForOrderBy(orderSpec, dimensions);
if (dimIndex >= 0) {
 fieldIndices.add(dimIndex);
 final ValueType type = dimensions.get(dimIndex).getOutputType();
 isNumericField.add(ValueType.isNumeric(type));
 comparators.add(orderSpec.getDimensionComparator());
} else {
 int aggIndex = OrderByColumnSpec.getAggIndexForOrderBy(orderSpec, Arrays.asList(aggregatorFactories));
 if (aggIndex >= 0) {
  fieldIndices.add(aggIndex);
  final String typeName = aggregatorFactories[aggIndex].getTypeName();
  isNumericField.add(ValueType.isNumeric(ValueType.fromString(typeName)));
  comparators.add(orderSpec.getDimensionComparator());