C++ SeqScanPlanNode::setOutputTable方法代码示例

bool SeqScanExecutor::p_init(AbstractPlanNode *abstract_node,
                             const catalog::Database* catalog_db,
                             int* tempTableMemoryInBytes) {
    VOLT_TRACE("init SeqScan Executor");

    SeqScanPlanNode* node = dynamic_cast<SeqScanPlanNode*>(abstract_node);
    assert(node);
    assert(node->getTargetTable());

    //
    // NESTED PROJECTION
    //
    if (node->getInlinePlanNode(PLAN_NODE_TYPE_PROJECTION) != NULL) {
        //std::cout << "Inline node:" << node->getInlinePlanNode(PLAN_NODE_TYPE_PROJECTION)->debug() << std::endl;
        ProjectionPlanNode* projection_node = static_cast<ProjectionPlanNode*>(node->getInlinePlanNode(PLAN_NODE_TYPE_PROJECTION));
        assert(projection_node);
        //
        // The internal node will already be initialized for us
        //
        // We just need to use the internal node's output table which
        // has been formatted correctly based on the projection
        // information as our own output table
        //
        assert(projection_node->getOutputTable());
        node->setOutputTable(projection_node->getOutputTable());
    //
    // FULL TABLE SCHEMA
    //
    } else {
        //
        // OPTIMIZATION: If there is no predicate for this SeqScan,
        // then we want to just set our OutputTable pointer to be the
        // pointer of our TargetTable. This prevents us from just
        // reading through the entire TargetTable and copying all of
        // the tuples. We are guarenteed that no Executor will ever
        // modify an input table, so this operation is safe
        //
        if (!this->needsOutputTableClear()) {
            node->setOutputTable(node->getTargetTable());
        //
        // Otherwise create a new temp table that mirrors the
        // TargetTable so that we can just copy the tuples right into
        // it. For now we are always use all of the columns, but in
        // the future we may want to have a projection work right
        // inside of the SeqScan
        //
        } else {
            node->setOutputTable(TableFactory::getCopiedTempTable(node->databaseId(),
                    node->getTargetTable()->name(),
                    node->getTargetTable(),
                    tempTableMemoryInBytes));
        }
    }
    return true;
}

bool SeqScanExecutor::p_init(AbstractPlanNode* abstract_node,
                             TempTableLimits* limits)
{
    VOLT_TRACE("init SeqScan Executor");

    SeqScanPlanNode* node = dynamic_cast<SeqScanPlanNode*>(abstract_node);
    assert(node);
    assert(node->getTargetTable());

    //
    // OPTIMIZATION: If there is no predicate for this SeqScan,
    // then we want to just set our OutputTable pointer to be the
    // pointer of our TargetTable. This prevents us from just
    // reading through the entire TargetTable and copying all of
    // the tuples. We are guarenteed that no Executor will ever
    // modify an input table, so this operation is safe
    //
    if (!this->needsOutputTableClear())
    {
        node->setOutputTable(node->getTargetTable());
    }
    //
    // Otherwise create a new temp table that mirrors the
    // output schema specified in the plan (which should mirror
    // the output schema for any inlined projection)
    //
    else
    {
        // Create output table based on output schema from the plan
        setTempOutputTable(limits, node->getTargetTable()->name());
    }
    return true;
}

bool SeqScanExecutor::p_init(AbstractPlanNode* abstract_node,
                             TempTableLimits* limits)
{
    VOLT_TRACE("init SeqScan Executor");

    SeqScanPlanNode* node = dynamic_cast<SeqScanPlanNode*>(abstract_node);
    assert(node);
    assert(node->getTargetTable());

    //
    // OPTIMIZATION: If there is no predicate for this SeqScan,
    // then we want to just set our OutputTable pointer to be the
    // pointer of our TargetTable. This prevents us from just
    // reading through the entire TargetTable and copying all of
    // the tuples. We are guarenteed that no Executor will ever
    // modify an input table, so this operation is safe
    //
    if (!this->needsOutputTableClear())
    {
        node->setOutputTable(node->getTargetTable());
    }
    //
    // Otherwise create a new temp table that mirrors the
    // output schema specified in the plan (which should mirror
    // the output schema for any inlined projection)
    //
    else
    {
        TupleSchema* schema = node->generateTupleSchema(true);
        int column_count = static_cast<int>(node->getOutputSchema().size());
        std::string* column_names = new std::string[column_count];
        for (int ctr = 0; ctr < column_count; ctr++)
        {
            column_names[ctr] = node->getOutputSchema()[ctr]->getColumnName();
        }
        node->setOutputTable(TableFactory::getTempTable(node->databaseId(),
                                                        node->getTargetTable()->name(),
                                                        schema,
                                                        column_names,
                                                        limits));
        delete[] column_names;
    }
    return true;
}

bool SeqScanExecutor::p_init(AbstractPlanNode* abstract_node,
                             TempTableLimits* limits)
{
    VOLT_TRACE("init SeqScan Executor");

    SeqScanPlanNode* node = dynamic_cast<SeqScanPlanNode*>(abstract_node);
    assert(node);
    bool isSubquery = node->isSubQuery();
    assert(isSubquery || node->getTargetTable());
    assert((! isSubquery) || (node->getChildren().size() == 1));

    //
    // OPTIMIZATION: If there is no predicate for this SeqScan,
    // then we want to just set our OutputTable pointer to be the
    // pointer of our TargetTable. This prevents us from just
    // reading through the entire TargetTable and copying all of
    // the tuples. We are guarenteed that no Executor will ever
    // modify an input table, so this operation is safe
    //
    if (node->getPredicate() != NULL || node->getInlinePlanNodes().size() > 0) {
        // Create output table based on output schema from the plan
        const std::string& temp_name = (node->isSubQuery()) ?
                node->getChildren()[0]->getOutputTable()->name():
                node->getTargetTable()->name();
        setTempOutputTable(limits, temp_name);
    }
    //
    // Otherwise create a new temp table that mirrors the
    // output schema specified in the plan (which should mirror
    // the output schema for any inlined projection)
    //
    else {
        node->setOutputTable(isSubquery ?
                             node->getChildren()[0]->getOutputTable() :
                             node->getTargetTable());
    }

    // Inline aggregation can be serial, partial or hash
    m_aggExec = voltdb::getInlineAggregateExecutor(node);

    return true;
}