aggregation-node.h

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.


#ifndef IMPALA_EXEC_AGGREGATION_NODE_H
#define IMPALA_EXEC_AGGREGATION_NODE_H

#include <functional>
#include <boost/scoped_ptr.hpp>

#include "exec/exec-node.h"
#include "exec/old-hash-table.h"
#include "runtime/descriptors.h"  // for TupleId
#include "runtime/mem-pool.h"
#include "runtime/string-value.h"

namespace llvm {
  class Function;
}

namespace impala {

class AggFnEvaluator;
class LlvmCodeGen;
class RowBatch;
class RuntimeState;
struct StringValue;
class Tuple;
class TupleDescriptor;
class SlotDescriptor;

//
class AggregationNode : public ExecNode {
 public:
  AggregationNode(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);

  static const char* LLVM_CLASS_NAME;

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

 private:
  boost::scoped_ptr<OldHashTable> hash_tbl_;
  OldHashTable::Iterator output_iterator_;

  std::vector<AggFnEvaluator*> aggregate_evaluators_;

  std::vector<impala_udf::FunctionContext*> agg_fn_ctxs_;
  boost::scoped_ptr<MemPool> agg_fn_pool_;

  std::vector<ExprContext*> probe_expr_ctxs_;
  std::vector<ExprContext*> build_expr_ctxs_;

  TupleId intermediate_tuple_id_;
  TupleDescriptor* intermediate_tuple_desc_;

  TupleId output_tuple_id_;
  TupleDescriptor* output_tuple_desc_;

  Tuple* singleton_intermediate_tuple_;

  boost::scoped_ptr<MemPool> tuple_pool_;

  llvm::Function* codegen_process_row_batch_fn_;

  typedef void (*ProcessRowBatchFn)(AggregationNode*, RowBatch*);
  ProcessRowBatchFn process_row_batch_fn_;

  bool needs_finalize_;

  RuntimeProfile::Counter* build_timer_;
  RuntimeProfile::Counter* get_results_timer_;
  RuntimeProfile::Counter* hash_table_buckets_counter_;
  RuntimeProfile::Counter* hash_table_load_factor_counter_;

  Tuple* ConstructIntermediateTuple();

  void UpdateTuple(Tuple* tuple, TupleRow* row);

  Tuple* FinalizeTuple(Tuple* tuple, MemPool* pool);

  void ProcessRowBatchNoGrouping(RowBatch* batch);
  void ProcessRowBatchWithGrouping(RowBatch* batch);

  llvm::Function* CodegenProcessRowBatch(
      RuntimeState* state, llvm::Function* update_tuple_fn);

  llvm::Function* CodegenUpdateSlot(
      RuntimeState* state, AggFnEvaluator* evaluator, SlotDescriptor* slot_desc);

  llvm::Function* CodegenUpdateTuple(RuntimeState* state);
};

}

#endif