org.apache.lens.cube.parse.CandidateUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lens-cube Show documentation
OLAP cube queries
The newest version!
/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 theJoinCandidate.java
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.lens.cube.parse;

import static org.apache.hadoop.hive.ql.parse.HiveParser.Identifier;

import java.util.*;
import java.util.stream.Collectors;

import org.apache.lens.cube.error.LensCubeErrorCode;
import org.apache.lens.server.api.error.LensException;

import org.apache.hadoop.hive.ql.lib.Node;
import org.apache.hadoop.hive.ql.parse.ASTNode;
import org.apache.hadoop.hive.ql.parse.HiveParser;

import org.antlr.runtime.CommonToken;

import com.google.common.collect.BoundType;
import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import com.google.common.collect.TreeRangeSet;

/**
 * Placeholder for Util methods that will be required for {@link Candidate}
 */
public final class CandidateUtil {

  private CandidateUtil() {
    // Added due to checkstyle error getting below :
    // (design) HideUtilityClassConstructor: Utility classes should not have a public or default constructor.
  }


  public static Set getStorageCandidates(final Candidate candidate) {
    return getStorageCandidates(new HashSet(1) {{ add(candidate); }});
  }

  /**
   * Returns true is the Candidates cover the entire time range.
   * @param candidates
   * @param startTime
   * @param endTime
   * @return
   */
  static boolean isTimeRangeCovered(Collection candidates, Date startTime, Date endTime) {
    RangeSet set = TreeRangeSet.create();
    for (Candidate candidate : candidates) {
      set.add(Range.range(candidate.getStartTime(), BoundType.CLOSED, candidate.getEndTime(), BoundType.OPEN));
    }
    return set.encloses(Range.range(startTime, BoundType.CLOSED, endTime, BoundType.OPEN));
  }

  public static Set getColumns(Collection queriedPhraseContexts) {
    Set cols = new HashSet<>();
    for (QueriedPhraseContext qur : queriedPhraseContexts) {
      cols.addAll(qur.getColumns());
    }
    return cols;
  }

  /**
   * Filters Candidates that contain the filterCandidate
   *
   * @param candidates
   * @param filterCandidate
   * @return pruned Candidates
   */
  public static Collection filterCandidates(Collection candidates, Candidate filterCandidate) {
    List prunedCandidates = new ArrayList<>();
    Iterator itr = candidates.iterator();
    while (itr.hasNext()) {
      Candidate cur = itr.next();
      if (cur.contains(filterCandidate)) {
        prunedCandidates.add(cur);
        itr.remove();
      }
    }
    return prunedCandidates;
  }

  /**
   * Gets all the Storage Candidates that participate in the collection of passed candidates
   *
   * @param candidates
   * @return
   */
  public static Set getStorageCandidates(Collection candidates) {
    Set storageCandidateSet = new HashSet<>();
    getStorageCandidates(candidates, storageCandidateSet);
    return storageCandidateSet;
  }

  private static void getStorageCandidates(Collection candidates,
    Collection storageCandidateSet) {
    for (Candidate candidate : candidates) {
      getStorageCandidates(candidate, storageCandidateSet);
    }
  }
  static void getStorageCandidates(Candidate candidate,
    Collection storageCandidateSet) {
    if (candidate.getChildren() == null) {
      // Expecting this to be a StorageCandidate as it has no children.
      if (candidate instanceof StorageCandidate) {
        storageCandidateSet.add((StorageCandidate) candidate);
      } else if (candidate instanceof SegmentationCandidate) {
        SegmentationCandidate segC = (SegmentationCandidate) candidate;
        for (CubeQueryContext cubeQueryContext : segC.cubeQueryContextMap.values()) {
          if (cubeQueryContext.getPickedCandidate() != null) {
            getStorageCandidates(cubeQueryContext.getPickedCandidate(), storageCandidateSet);
          }
        }
      }
    } else {
      getStorageCandidates(candidate.getChildren(), storageCandidateSet);
    }
  }

  /**
   *
   * @param selectAST Outer query selectAST
   * @param cubeql Cubequery Context
   *
   *  Update the final alias in the outer select expressions
   *  1. Replace queriedAlias with finalAlias if both are not same
   *  2. If queriedAlias is missing add finalAlias as alias
   */
  static void updateFinalAlias(ASTNode selectAST, CubeQueryContext cubeql) {
    for (int i = 0; i < selectAST.getChildCount(); i++) {
      ASTNode selectExpr = (ASTNode) selectAST.getChild(i);
      ASTNode aliasNode = HQLParser.findNodeByPath(selectExpr, Identifier);
      String finalAlias = cubeql.getSelectPhrases().get(i).getFinalAlias().replaceAll("`", "");
      if (aliasNode != null) {
        String queryAlias = aliasNode.getText();
        if (!queryAlias.equals(finalAlias)) {
          // replace the alias node
          ASTNode newAliasNode = new ASTNode(new CommonToken(HiveParser.Identifier, finalAlias));
          selectAST.getChild(i).replaceChildren(selectExpr.getChildCount() - 1,
              selectExpr.getChildCount() - 1, newAliasNode);
        }
      } else {
        // add column alias
        ASTNode newAliasNode = new ASTNode(new CommonToken(HiveParser.Identifier, finalAlias));
        selectAST.getChild(i).addChild(newAliasNode);
      }
    }
  }
  static Set getColumnsFromCandidates(Collection scSet) {
    return scSet.stream().map(Candidate::getColumns).flatMap(Collection::stream).collect(Collectors.toSet());
  }

  static void updateOrderByWithFinalAlias(ASTNode orderby, ASTNode select) throws LensException{
    if (orderby == null) {
      return;
    }
    for (Node orderbyNode : orderby.getChildren()) {
      ASTNode orderBychild = (ASTNode) orderbyNode;
      for (Node selectNode : select.getChildren()) {
        ASTNode selectChild = (ASTNode) selectNode;
        if (selectChild.getChildCount() == 2) {
          if (HQLParser.getString((ASTNode) selectChild.getChild(0))
              .equals(HQLParser.getString((ASTNode) orderBychild.getChild(0)))) {
            ASTNode alias = new ASTNode((ASTNode) selectChild.getChild(1));
            if (!alias.toString().matches("\\S+")) {
              throw new LensException(LensCubeErrorCode.ORDERBY_ALIAS_CONTAINING_WHITESPACE.getLensErrorInfo(), alias);
            }
            orderBychild.replaceChildren(0, 0, alias);
            break;
          }
        }
      }
    }
  }
}