ExprSubstitutionMap.java

Go to the documentation of this file.

package com.cloudera.impala.analysis;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;

public final class ExprSubstitutionMap {
  private final static Logger LOG = LoggerFactory.getLogger(ExprSubstitutionMap.class);

  private List<Expr> lhs_; // left-hand side
  private List<Expr> rhs_; // right-hand side

  public ExprSubstitutionMap() {
    this(Lists.<Expr>newArrayList(), Lists.<Expr>newArrayList());
  }

  public ExprSubstitutionMap(List<Expr> lhs, List<Expr> rhs) {
    lhs_ = lhs;
    rhs_ = rhs;
  }

  public void put(Expr lhsExpr, Expr rhsExpr) {
    Preconditions.checkState(rhsExpr.isAnalyzed_, "Rhs expr must be analyzed.");
    lhs_.add(lhsExpr);
    rhs_.add(rhsExpr);
  }

  public Expr get(Expr lhsExpr) {
    for (int i = 0; i < lhs_.size(); ++i) {
      if (lhsExpr.equals(lhs_.get(i))) return rhs_.get(i);
    }
    return null;
  }

  public boolean containsMappingFor(Expr lhsExpr) {
    return lhs_.contains(lhsExpr);
  }

  public static ExprSubstitutionMap compose(ExprSubstitutionMap f, ExprSubstitutionMap g,
      Analyzer analyzer) {
    if (f == null && g == null) return new ExprSubstitutionMap();
    if (f == null) return g;
    if (g == null) return f;
    ExprSubstitutionMap result = new ExprSubstitutionMap();
    // f's substitution targets need to be substituted via g
    result.lhs_ = Expr.cloneList(f.lhs_);
    result.rhs_ = Expr.substituteList(f.rhs_, g, analyzer, false);

    // substitution maps are cumulative: the combined map contains all
    // substitutions from f and g.
    for (int i = 0; i < g.lhs_.size(); i++) {
      // If f contains expr1->fn(expr2) and g contains expr2->expr3,
      // then result must contain expr1->fn(expr3).
      // The check before adding to result.lhs is to ensure that cases
      // where expr2.equals(expr1) are handled correctly.
      // For example f: count(*) -> zeroifnull(count(*))
      // and g: count(*) -> slotref
      // result.lhs must only have: count(*) -> zeroifnull(slotref) from f above,
      // and not count(*) -> slotref from g as well.
      if (!result.lhs_.contains(g.lhs_.get(i))) {
        result.lhs_.add(g.lhs_.get(i).clone());
        result.rhs_.add(g.rhs_.get(i).clone());
      }
    }

    result.verify();
    return result;
  }

  public static ExprSubstitutionMap combine(ExprSubstitutionMap f,
      ExprSubstitutionMap g) {
    if (f == null && g == null) return new ExprSubstitutionMap();
    if (f == null) return g;
    if (g == null) return f;
    ExprSubstitutionMap result = new ExprSubstitutionMap();
    result.lhs_ = Lists.newArrayList(f.lhs_);
    result.lhs_.addAll(g.lhs_);
    result.rhs_ = Lists.newArrayList(f.rhs_);
    result.rhs_.addAll(g.rhs_);
    result.verify();
    return result;
  }

  public void substituteLhs(ExprSubstitutionMap lhsSmap, Analyzer analyzer) {
    lhs_ = Expr.substituteList(lhs_, lhsSmap, analyzer, false);
  }

  public List<Expr> getLhs() { return lhs_; }
  public List<Expr> getRhs() { return rhs_; }

  public int size() { return lhs_.size(); }

  public String debugString() {
    Preconditions.checkState(lhs_.size() == rhs_.size());
    List<String> output = Lists.newArrayList();
    for (int i = 0; i < lhs_.size(); ++i) {
      output.add(lhs_.get(i).toSql() + ":" + rhs_.get(i).toSql());
      output.add("(" + lhs_.get(i).debugString() + ":" + rhs_.get(i).debugString() + ")");
    }
    return "smap(" + Joiner.on(" ").join(output) + ")";
  }

  private void verify() {
    for (int i = 0; i < lhs_.size(); ++i) {
      for (int j = i + 1; j < lhs_.size(); ++j) {
        if (lhs_.get(i).equals(lhs_.get(j))) {
          LOG.info("verify: smap=" + this.debugString());
          Preconditions.checkState(false);
        }
      }
      Preconditions.checkState(rhs_.get(i).isAnalyzed_);
    }
  }

  public void clear() {
    lhs_.clear();
    rhs_.clear();
  }
}