/**
* When this function is called, the AbstractExecutor's init function
* will have set the input tables in the plan node, but nothing else.
*/
bool WindowFunctionExecutor::p_init(AbstractPlanNode *init_node, TempTableLimits *limits) {
VOLT_TRACE("WindowFunctionExecutor::p_init(start)");
WindowFunctionPlanNode* node = dynamic_cast<WindowFunctionPlanNode*>(m_abstractNode);
assert(node);
if (!node->isInline()) {
setTempOutputTable(limits);
}
/*
* Initialize the memory pool early, so that we can
* use it for constructing temp. tuples.
*/
m_memoryPool.purge();
assert( getInProgressPartitionByKeyTuple().isNullTuple());
assert( getInProgressOrderByKeyTuple().isNullTuple());
assert( getLastPartitionByKeyTuple().isNullTuple());
assert( getLastOrderByKeyTuple().isNullTuple());
m_partitionByKeySchema = TupleSchema::createTupleSchema(m_partitionByExpressions);
m_orderByKeySchema = TupleSchema::createTupleSchema(m_orderByExpressions);
/*
* Initialize all the data for partition by and
* order by storage once and for all.
*/
VOLT_TRACE("WindowFunctionExecutor::p_init(end)\n");
return true;
}
bool ReceiveExecutor::p_init(AbstractPlanNode* abstract_node,
TempTableLimits* limits)
{
VOLT_TRACE("init Receive Executor");
assert(dynamic_cast<ReceivePlanNode*>(abstract_node));
// Create output table based on output schema from the plan
setTempOutputTable(limits);
return true;
}
bool ProjectionExecutor::p_init(AbstractPlanNode *abstractNode,
TempTableLimits* limits)
{
VOLT_TRACE("init Projection Executor");
assert(limits);
ProjectionPlanNode* node = dynamic_cast<ProjectionPlanNode*>(abstractNode);
assert(node);
// Create output table based on output schema from the plan
setTempOutputTable(limits);
m_columnCount = static_cast<int>(node->getOutputSchema().size());
// initialize local variables
all_tuple_array_ptr = ExpressionUtil::convertIfAllTupleValues(node->getOutputColumnExpressions());
all_tuple_array = all_tuple_array_ptr.get();
all_param_array_ptr = ExpressionUtil::convertIfAllParameterValues(node->getOutputColumnExpressions());
all_param_array = all_param_array_ptr.get();
needs_substitute_ptr = boost::shared_array<bool>(new bool[m_columnCount]);
needs_substitute = needs_substitute_ptr.get();
typedef AbstractExpression* ExpRawPtr;
expression_array_ptr = boost::shared_array<ExpRawPtr>(new ExpRawPtr[m_columnCount]);
expression_array = expression_array_ptr.get();
for (int ctr = 0; ctr < m_columnCount; ctr++) {
assert (node->getOutputColumnExpressions()[ctr] != NULL);
VOLT_TRACE("OutputColumnExpressions [%d]: %s", ctr,
node->getOutputColumnExpressions()[ctr]->debug(true).c_str());
expression_array_ptr[ctr] = node->getOutputColumnExpressions()[ctr];
needs_substitute_ptr[ctr] = node->getOutputColumnExpressions()[ctr]->hasParameter();
}
output_table = dynamic_cast<TempTable*>(node->getOutputTable()); //output table should be temptable
if (!node->isInline()) {
Table* input_table = node->getInputTable();
tuple = TableTuple(input_table->schema());
}
return true;
}
bool MaterializeExecutor::p_init(AbstractPlanNode* abstractNode,
TempTableLimits* limits)
{
VOLT_TRACE("init Materialize Executor");
node = dynamic_cast<MaterializePlanNode*>(abstractNode);
assert(node);
batched = node->isBatched();
// Construct the output table
m_columnCount = static_cast<int>(node->getOutputSchema().size());
assert(m_columnCount >= 0);
// Create output table based on output schema from the plan
setTempOutputTable(limits);
// initialize local variables
all_param_array_ptr = ExpressionUtil::convertIfAllParameterValues(node->getOutputColumnExpressions());
all_param_array = all_param_array_ptr.get();
needs_substitute_ptr = boost::shared_array<bool>(new bool[m_columnCount]);
needs_substitute = needs_substitute_ptr.get();
expression_array_ptr =
boost::shared_array<AbstractExpression*>(new AbstractExpression*[m_columnCount]);
expression_array = expression_array_ptr.get();
for (int ctr = 0; ctr < m_columnCount; ctr++) {
assert (node->getOutputColumnExpressions()[ctr] != NULL);
expression_array_ptr[ctr] = node->getOutputColumnExpressions()[ctr];
needs_substitute_ptr[ctr] = node->getOutputColumnExpressions()[ctr]->hasParameter();
}
//output table should be temptable
output_table = dynamic_cast<TempTable*>(node->getOutputTable());
return (true);
}
bool AggregateExecutorBase::p_init(AbstractPlanNode*, TempTableLimits* limits)
{
AggregatePlanNode* node = dynamic_cast<AggregatePlanNode*>(m_abstractNode);
assert(node);
m_inputExpressions = node->getAggregateInputExpressions();
for (int i = 0; i < m_inputExpressions.size(); i++) {
VOLT_DEBUG("AGG INPUT EXPRESSION[%d]: %s",
i,
m_inputExpressions[i] ? m_inputExpressions[i]->debug().c_str() : "null");
}
/*
* Find the difference between the set of aggregate output columns
* (output columns resulting from an aggregate) and output columns.
* Columns that are not the result of aggregates are being passed
* through from the input table. Do this extra work here rather then
* serialize yet more data.
*/
std::vector<bool> outputColumnsResultingFromAggregates(node->getOutputSchema().size(), false);
m_aggregateOutputColumns = node->getAggregateOutputColumns();
BOOST_FOREACH(int aOC, m_aggregateOutputColumns) {
outputColumnsResultingFromAggregates[aOC] = true;
}
for (int ii = 0; ii < outputColumnsResultingFromAggregates.size(); ii++) {
if (outputColumnsResultingFromAggregates[ii] == false) {
m_passThroughColumns.push_back(ii);
}
}
if (!node->isInline()) {
setTempOutputTable(limits);
}
m_partialSerialGroupByColumns = node->getPartialGroupByColumns();
m_aggTypes = node->getAggregates();
m_distinctAggs = node->getDistinctAggregates();
m_groupByExpressions = node->getGroupByExpressions();
node->collectOutputExpressions(m_outputColumnExpressions);
// m_passThroughColumns.size() == m_groupByExpressions.size() is not true,
// Because group by unique column may be able to select other columns
m_prePredicate = node->getPrePredicate();
m_postPredicate = node->getPostPredicate();
m_groupByKeySchema = constructGroupBySchema(false);
m_groupByKeyPartialHashSchema = NULL;
if (m_partialSerialGroupByColumns.size() > 0) {
for (int ii = 0; ii < m_groupByExpressions.size(); ii++) {
if (std::find(m_partialSerialGroupByColumns.begin(),
m_partialSerialGroupByColumns.end(), ii)
== m_partialSerialGroupByColumns.end() )
{
// Find the partial hash group by columns
m_partialHashGroupByColumns.push_back(ii);;
}
}
m_groupByKeyPartialHashSchema = constructGroupBySchema(true);
}
return true;
}
bool AggregateExecutorBase::p_init(AbstractPlanNode*, TempTableLimits* limits)
{
AggregatePlanNode* node = dynamic_cast<AggregatePlanNode*>(m_abstractNode);
assert(node);
assert(node->getChildren().size() == 1);
assert(node->getChildren()[0] != NULL);
m_inputExpressions = node->getAggregateInputExpressions();
for (int i = 0; i < m_inputExpressions.size(); i++) {
VOLT_DEBUG("\nAGG INPUT EXPRESSION: %s\n",
m_inputExpressions[i] ? m_inputExpressions[i]->debug().c_str() : "null");
}
/*
* Find the difference between the set of aggregate output columns
* (output columns resulting from an aggregate) and output columns.
* Columns that are not the result of aggregates are being passed
* through from the input table. Do this extra work here rather then
* serialize yet more data.
*/
std::vector<bool> outputColumnsResultingFromAggregates(node->getOutputSchema().size(), false);
std::vector<int> aggregateOutputColumns = node->getAggregateOutputColumns();
BOOST_FOREACH(int aOC, aggregateOutputColumns) {
outputColumnsResultingFromAggregates[aOC] = true;
}
/*
* Now collect the indices in the output table of the pass
* through columns.
*/
for (int ii = 0; ii < outputColumnsResultingFromAggregates.size(); ii++) {
if (outputColumnsResultingFromAggregates[ii] == false) {
m_passThroughColumns.push_back(ii);
}
}
setTempOutputTable(limits);
m_aggTypes = node->getAggregates();
m_distinctAggs = node->getDistinctAggregates();
m_groupByExpressions = node->getGroupByExpressions();
node->collectOutputExpressions(m_outputColumnExpressions);
m_aggregateOutputColumns = node->getAggregateOutputColumns();
m_prePredicate = node->getPrePredicate();
m_postPredicate = node->getPostPredicate();
std::vector<ValueType> groupByColumnTypes;
std::vector<int32_t> groupByColumnSizes;
std::vector<bool> groupByColumnAllowNull;
for (int ii = 0; ii < m_groupByExpressions.size(); ii++) {
AbstractExpression* expr = m_groupByExpressions[ii];
groupByColumnTypes.push_back(expr->getValueType());
groupByColumnSizes.push_back(expr->getValueSize());
groupByColumnAllowNull.push_back(true);
}
m_groupByKeySchema = TupleSchema::createTupleSchema(groupByColumnTypes,
groupByColumnSizes,
groupByColumnAllowNull,
true);
return true;
}
