database/doris
2
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

[CodeFormat] Clang-format cpp sources (#4965)

Browse Source 
Clang-format all c++ source files.
This commit is contained in:
sduzh
2020-11-28 18:36:49 +08:00
committed by GitHub
parent f944bf4d44
commit 6fedf5881b
1331 changed files with 62548 additions and 68514 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
be/src/exec/aggregation_node.cpp
View File

@ -17,11 +17,12 @@
#include "exec/aggregation_node.h"
#include <math.h>
#include <sstream>
#include <boost/functional/hash.hpp>
#include <thrift/protocol/TDebugProtocol.h>
#include <gperftools/profiler.h>
#include <math.h>
#include <thrift/protocol/TDebugProtocol.h>
#include <boost/functional/hash.hpp>
#include <sstream>
#include "exec/hash_table.hpp"
#include "exprs/agg_fn_evaluator.h"
@ -44,36 +45,33 @@ namespace doris {
// TODO: pass in maximum size; enforce by setting limit in mempool
// TODO: have a Status ExecNode::init(const TPlanNode&) member function
// that does initialization outside of c'tor, so we can indicate errors
AggregationNode::AggregationNode(
ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs) :
ExecNode(pool, tnode, descs),
_intermediate_tuple_id(tnode.agg_node.intermediate_tuple_id),
_intermediate_tuple_desc(NULL),
_output_tuple_id(tnode.agg_node.output_tuple_id),
_output_tuple_desc(NULL),
_singleton_output_tuple(NULL),
//_tuple_pool(new MemPool()),
//
_process_row_batch_fn(NULL),
_needs_finalize(tnode.agg_node.need_finalize),
_build_timer(NULL),
_get_results_timer(NULL),
_hash_table_buckets_counter(NULL) {
}
AggregationNode::AggregationNode(ObjectPool* pool, const TPlanNode& tnode,
const DescriptorTbl& descs)
: ExecNode(pool, tnode, descs),
_intermediate_tuple_id(tnode.agg_node.intermediate_tuple_id),
_intermediate_tuple_desc(NULL),
_output_tuple_id(tnode.agg_node.output_tuple_id),
_output_tuple_desc(NULL),
_singleton_output_tuple(NULL),
//_tuple_pool(new MemPool()),
//
_process_row_batch_fn(NULL),
_needs_finalize(tnode.agg_node.need_finalize),
_build_timer(NULL),
_get_results_timer(NULL),
_hash_table_buckets_counter(NULL) {}
AggregationNode::~AggregationNode() {
}
AggregationNode::~AggregationNode() {}
Status AggregationNode::init(const TPlanNode& tnode, RuntimeState* state) {
RETURN_IF_ERROR(ExecNode::init(tnode, state));
// ignore return status for now , so we need to introduce ExecNode::init()
RETURN_IF_ERROR(Expr::create_expr_trees(
_pool, tnode.agg_node.grouping_exprs, &_probe_expr_ctxs));
RETURN_IF_ERROR(
Expr::create_expr_trees(_pool, tnode.agg_node.grouping_exprs, &_probe_expr_ctxs));
for (int i = 0; i < tnode.agg_node.aggregate_functions.size(); ++i) {
AggFnEvaluator* evaluator = NULL;
AggFnEvaluator::create(
_pool, tnode.agg_node.aggregate_functions[i], &evaluator);
AggFnEvaluator::create(_pool, tnode.agg_node.aggregate_functions[i], &evaluator);
_aggregate_evaluators.push_back(evaluator);
}
return Status::OK();
@ -83,19 +81,17 @@ Status AggregationNode::prepare(RuntimeState* state) {
RETURN_IF_ERROR(ExecNode::prepare(state));
_build_timer = ADD_TIMER(runtime_profile(), "BuildTime");
_get_results_timer = ADD_TIMER(runtime_profile(), "GetResultsTime");
_hash_table_buckets_counter =
ADD_COUNTER(runtime_profile(), "BuildBuckets", TUnit::UNIT);
_hash_table_buckets_counter = ADD_COUNTER(runtime_profile(), "BuildBuckets", TUnit::UNIT);
_hash_table_load_factor_counter =
ADD_COUNTER(runtime_profile(), "LoadFactor", TUnit::DOUBLE_VALUE);
ADD_COUNTER(runtime_profile(), "LoadFactor", TUnit::DOUBLE_VALUE);
SCOPED_TIMER(_runtime_profile->total_time_counter());
_intermediate_tuple_desc =
state->desc_tbl().get_tuple_descriptor(_intermediate_tuple_id);
_intermediate_tuple_desc = state->desc_tbl().get_tuple_descriptor(_intermediate_tuple_id);
_output_tuple_desc = state->desc_tbl().get_tuple_descriptor(_output_tuple_id);
DCHECK_EQ(_intermediate_tuple_desc->slots().size(), _output_tuple_desc->slots().size());
RETURN_IF_ERROR(Expr::prepare(
_probe_expr_ctxs, state, child(0)->row_desc(), expr_mem_tracker()));
RETURN_IF_ERROR(
Expr::prepare(_probe_expr_ctxs, state, child(0)->row_desc(), expr_mem_tracker()));
// Construct build exprs from _agg_tuple_desc
for (int i = 0; i < _probe_expr_ctxs.size(); ++i) {
@ -110,8 +106,7 @@ Status AggregationNode::prepare(RuntimeState* state) {
// nor this node's output row desc may contain the intermediate tuple, e.g.,
// in a single-node plan with an intermediate tuple different from the output tuple.
RowDescriptor build_row_desc(_intermediate_tuple_desc, false);
RETURN_IF_ERROR(Expr::prepare(
_build_expr_ctxs, state, build_row_desc, expr_mem_tracker()));
RETURN_IF_ERROR(Expr::prepare(_build_expr_ctxs, state, build_row_desc, expr_mem_tracker()));
_tuple_pool.reset(new MemPool(mem_tracker().get()));
@ -134,9 +129,9 @@ Status AggregationNode::prepare(RuntimeState* state) {
}
// TODO: how many buckets?
_hash_tbl.reset(new HashTable(
_build_expr_ctxs, _probe_expr_ctxs, 1, true,
std::vector<bool>(_build_expr_ctxs.size(), false), id(), mem_tracker(), 1024));
_hash_tbl.reset(new HashTable(_build_expr_ctxs, _probe_expr_ctxs, 1, true,
std::vector<bool>(_build_expr_ctxs.size(), false), id(),
mem_tracker(), 1024));
if (_probe_expr_ctxs.empty()) {
// create single output tuple now; we need to output something
@ -177,8 +172,8 @@ Status AggregationNode::open(RuntimeState* state) {
if (VLOG_ROW_IS_ON) {
for (int i = 0; i < batch.num_rows(); ++i) {
TupleRow* row = batch.get_row(i);
VLOG_ROW << "id=" << id() << " input row: "
<< row->to_string(_children[0]->row_desc());
VLOG_ROW << "id=" << id()
<< " input row: " << row->to_string(_children[0]->row_desc());
}
}
@ -223,7 +218,7 @@ Status AggregationNode::open(RuntimeState* state) {
}
VLOG_ROW << "id=" << id() << " aggregated " << num_input_rows << " input rows into "
<< num_agg_rows << " output rows";
<< num_agg_rows << " output rows";
_output_iterator = _hash_tbl->begin();
return Status::OK();
}
@ -255,8 +250,7 @@ Status AggregationNode::get_next(RuntimeState* state, RowBatch* row_batch, bool*
int row_idx = row_batch->add_row();
TupleRow* row = row_batch->get_row(row_idx);
Tuple* intermediate_tuple = _output_iterator.get_row()->get_tuple(0);
Tuple* output_tuple =
finalize_tuple(intermediate_tuple, row_batch->tuple_data_pool());
Tuple* output_tuple = finalize_tuple(intermediate_tuple, row_batch->tuple_data_pool());
row->set_tuple(0, output_tuple);
if (ExecNode::eval_conjuncts(ctxs, num_ctxs, row)) {
@ -274,8 +268,7 @@ Status AggregationNode::get_next(RuntimeState* state, RowBatch* row_batch, bool*
*eos = _output_iterator.at_end() || reached_limit();
if (*eos) {
if (_hash_tbl.get() != NULL &&
_hash_table_buckets_counter != NULL) {
if (_hash_tbl.get() != NULL && _hash_table_buckets_counter != NULL) {
COUNTER_SET(_hash_table_buckets_counter, _hash_tbl->num_buckets());
}
}
@ -328,7 +321,8 @@ Status AggregationNode::close(RuntimeState* state) {
Tuple* AggregationNode::construct_intermediate_tuple() {
Tuple* agg_tuple = Tuple::create(_intermediate_tuple_desc->byte_size(), _tuple_pool.get());
std::vector<SlotDescriptor*>::const_iterator slot_desc = _intermediate_tuple_desc->slots().begin();
std::vector<SlotDescriptor*>::const_iterator slot_desc =
_intermediate_tuple_desc->slots().begin();
// copy grouping values
for (int i = 0; i < _probe_expr_ctxs.size(); ++i, ++slot_desc) {
@ -359,8 +353,7 @@ Tuple* AggregationNode::construct_intermediate_tuple() {
// - max: min_value
// TODO: remove when we don't use the irbuilder for codegen here.
// This optimization no longer applies with AnyVal
if (!(*slot_desc)->type().is_string_type() &&
!(*slot_desc)->type().is_date_type()) {
if (!(*slot_desc)->type().is_string_type() && !(*slot_desc)->type().is_date_type()) {
ExprValue default_value;
void* default_value_ptr = NULL;
@ -434,20 +427,18 @@ Tuple* AggregationNode::finalize_tuple(Tuple* tuple, MemPool* pool) {
void AggregationNode::debug_string(int indentation_level, std::stringstream* out) const {
*out << std::string(indentation_level * 2, ' ');
*out << "AggregationNode(intermediate_tuple_id=" << _intermediate_tuple_id
<< " output_tuple_id=" << _output_tuple_id
<< " needs_finalize=" << _needs_finalize
<< " output_tuple_id=" << _output_tuple_id << " needs_finalize="
<< _needs_finalize
// << " probe_exprs=" << Expr::debug_string(_probe_exprs)
<< " agg_exprs=" << AggFnEvaluator::debug_string(_aggregate_evaluators);
ExecNode::debug_string(indentation_level, out);
*out << ")";
}
void AggregationNode::push_down_predicate(RuntimeState *state,
std::list<ExprContext*> *expr_ctxs) {
void AggregationNode::push_down_predicate(RuntimeState* state, std::list<ExprContext*>* expr_ctxs) {
// groupby can pushdown, agg can't pushdown
// Now we doesn't pushdown for easy.
return;
}
}
} // namespace doris