OrderByElement.java

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.cloudera.impala.analysis;

import java.util.List;

import com.google.common.collect.Lists;


public class OrderByElement {
  private Expr expr_;
  private final boolean isAsc_;
  // Represents the NULLs ordering specified: true when "NULLS FIRST", false when
  // "NULLS LAST", and null if not specified.
  private final Boolean nullsFirstParam_;

  public OrderByElement(Expr expr, boolean isAsc, Boolean nullsFirstParam) {
    super();
    this.expr_ = expr;
    this.isAsc_ = isAsc;
    this.nullsFirstParam_ = nullsFirstParam;
  }

  public Expr getExpr() { return expr_; }
  public void setExpr(Expr e) { expr_ = e; }
  public boolean isAsc() { return isAsc_; }
  public Boolean getNullsFirstParam() { return nullsFirstParam_; }
  public boolean nullsFirst() { return nullsFirst(nullsFirstParam_, isAsc_); }

  public String toSql() {
    StringBuilder strBuilder = new StringBuilder();
    strBuilder.append(expr_.toSql());
    strBuilder.append(isAsc_ ? " ASC" : " DESC");
    // When ASC and NULLS LAST or DESC and NULLS FIRST, we do not print NULLS FIRST/LAST
    // because it is the default behavior and we want to avoid printing NULLS FIRST/LAST
    // whenever possible as it is incompatible with Hive (SQL compatibility with Hive is
    // important for views).
    if (nullsFirstParam_ != null) {
      if (isAsc_ && nullsFirstParam_) {
        // If ascending, nulls are last by default, so only add if nulls first.
        strBuilder.append(" NULLS FIRST");
      } else if (!isAsc_ && !nullsFirstParam_) {
        // If descending, nulls are first by default, so only add if nulls last.
        strBuilder.append(" NULLS LAST");
      }
    }
    return strBuilder.toString();
  }

  @Override
  public boolean equals(Object obj) {
    if (obj == null) return false;
    if (obj.getClass() != this.getClass()) return false;
    OrderByElement o = (OrderByElement)obj;
    boolean nullsFirstEqual =
      (nullsFirstParam_ == null) == (o.nullsFirstParam_ == null);
    if (nullsFirstParam_ != null && nullsFirstEqual) {
      nullsFirstEqual = nullsFirstParam_.equals(o.nullsFirstParam_);
    }
    return expr_.equals(o.expr_) && isAsc_ == o.isAsc_ && nullsFirstEqual;
  }

  @Override
  public OrderByElement clone() {
    OrderByElement clone = new OrderByElement(
        expr_.clone(), isAsc_,
        nullsFirstParam_ != null ? new Boolean(nullsFirstParam_.booleanValue()) : null);
    return clone;
  }


  public static boolean nullsFirst(Boolean nullsFirstParam, boolean isAsc) {
    return nullsFirstParam == null ? !isAsc : nullsFirstParam;
  }

  public static List<OrderByElement> substitute(List<OrderByElement> src,
      ExprSubstitutionMap smap, Analyzer analyzer) {
    List<OrderByElement> result = Lists.newArrayListWithCapacity(src.size());
    for (OrderByElement element: src) {
      result.add(new OrderByElement(element.getExpr().substitute(smap, analyzer, false),
          element.isAsc_, element.nullsFirstParam_));
    }
    return result;
  }

  public static List<Expr> getOrderByExprs(List<OrderByElement> src) {
    List<Expr> result = Lists.newArrayListWithCapacity(src.size());
    for (OrderByElement element: src) {
      result.add(element.getExpr());
    }
    return result;
  }

  public static List<OrderByElement> reverse(List<OrderByElement> src) {
    List<OrderByElement> result = Lists.newArrayListWithCapacity(src.size());
    for (int i = 0; i < src.size(); ++i) {
      OrderByElement element = src.get(i);
      OrderByElement reverseElement =
          new OrderByElement(element.getExpr().clone(), !element.isAsc_,
              Boolean.valueOf(!nullsFirst(element.nullsFirstParam_, element.isAsc_)));
      result.add(reverseElement);
    }
    return result;
  }
}