analytic-eval-node.h

Go to the documentation of this file.

// Copyright 2014 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.

#ifndef IMPALA_EXEC_ANALYTIC_EVAL_NODE_H
#define IMPALA_EXEC_ANALYTIC_EVAL_NODE_H

#include "exec/exec-node.h"
#include "exprs/expr.h"
#include "exprs/expr-context.h"
#include "runtime/buffered-block-mgr.h"
#include "runtime/buffered-tuple-stream.h"
#include "runtime/tuple.h"

namespace impala {

class AggFnEvaluator;

//
//
//
class AnalyticEvalNode : public ExecNode {
 public:
  AnalyticEvalNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);

  virtual Status Init(const TPlanNode& tnode);
  virtual Status Prepare(RuntimeState* state);
  virtual Status Open(RuntimeState* state);
  virtual Status GetNext(RuntimeState* state, RowBatch* row_batch, bool* eos);
  virtual Status Reset(RuntimeState* state);
  virtual void Close(RuntimeState* state);

 protected:
  virtual Status QueryMaintenance(RuntimeState* state);

  virtual void DebugString(int indentation_level, std::stringstream* out) const;

 private:
  enum AnalyticFnScope {
    PARTITION,

    RANGE,

    ROWS
  };

  Status ProcessChildBatch(RuntimeState* state);

  Status ProcessChildBatches(RuntimeState* state);

  Status GetNextOutputBatch(RuntimeState* state, RowBatch* row_batch, bool* eos);

  Status AddRow(int64_t stream_idx, TupleRow* row);

  void TryAddResultTupleForPrevRow(bool next_partition, int64_t stream_idx,
      TupleRow* row);

  void TryAddResultTupleForCurrRow(int64_t stream_idx, TupleRow* row);

  void TryAddRemainingResults(int64_t partition_idx, int64_t prev_partition_idx);

  void TryRemoveRowsBeforeWindow(int64_t stream_idx);

  void InitNextPartition(int64_t stream_idx);

  void AddResultTuple(int64_t stream_idx);

  int64_t NumOutputRowsReady() const;

  void ResetLeadFnSlots();

  bool PrevRowCompare(ExprContext* pred_ctx);

  std::string DebugStateString(bool detailed) const;

  std::string DebugEvaluatedRowsString() const;

  std::string DebugWindowString() const;

  const TAnalyticWindow window_;

  const TupleDescriptor* intermediate_tuple_desc_;

  const TupleDescriptor* result_tuple_desc_;

  TupleDescriptor* buffered_tuple_desc_;

  TupleRow* child_tuple_cmp_row_;

  ExprContext* partition_by_eq_expr_ctx_;

  ExprContext* order_by_eq_expr_ctx_;

  AnalyticFnScope fn_scope_;

  int64_t rows_start_offset_;
  int64_t rows_end_offset_;

  std::vector<AggFnEvaluator*> evaluators_;

  std::vector<bool> is_lead_fn_;

  bool has_first_val_null_offset_;
  long first_val_null_offset_;

  std::vector<impala_udf::FunctionContext*> fn_ctxs_;

  std::list<std::pair<int64_t, Tuple*> > result_tuples_;

  int64_t last_result_idx_;

  std::list<std::pair<int64_t, Tuple*> > window_tuples_;
  TupleDescriptor* child_tuple_desc_;

  boost::scoped_ptr<MemPool> curr_tuple_pool_;
  boost::scoped_ptr<MemPool> prev_tuple_pool_;

  int64_t prev_pool_last_result_idx_;

  int64_t prev_pool_last_window_idx_;

  Tuple* curr_tuple_;

  Tuple* dummy_result_tuple_;

  int64_t curr_partition_idx_;

  TupleRow* prev_input_row_;

  boost::scoped_ptr<RowBatch> prev_child_batch_;
  boost::scoped_ptr<RowBatch> curr_child_batch_;

  BufferedBlockMgr::Client* client_;

  boost::scoped_ptr<BufferedTupleStream> input_stream_;

  boost::scoped_ptr<MemPool> mem_pool_;

  bool input_eos_;

  RuntimeProfile::Counter* evaluation_timer_;
};

}

#endif