Пример #1
0
void AbstractScanPlanNode::loadFromJSONObject(PlannerDomValue obj)
{
    m_target_table_name = obj.valueForKey("TARGET_TABLE_NAME").asStr();

    m_isEmptyScan = obj.hasNonNullKey("PREDICATE_FALSE");

    // Set the predicate (if any) only if it's not a trivial FALSE expression
    if (!m_isEmptyScan) {
        m_predicate.reset(loadExpressionFromJSONObject("PREDICATE", obj));
    }

    m_tcd = NULL;
    m_cteStmtId = -1;
    if (obj.hasKey("IS_CTE_SCAN") && obj.valueForKey("IS_CTE_SCAN").asBool()) {
        m_scanType = CTE_SCAN;
        m_cteStmtId = obj.valueForKey("CTE_STMT_ID").asInt();
    }
    else if (obj.hasNonNullKey("SUBQUERY_INDICATOR")) {
        m_scanType = SUBQUERY_SCAN;
    }
    else {
        m_scanType = PERSISTENT_TABLE_SCAN;
        VoltDBEngine* engine = ExecutorContext::getEngine();
        m_tcd = engine->getTableDelegate(m_target_table_name);
        if ( ! m_tcd) {
            VOLT_ERROR("Failed to retrieve target table from execution engine for PlanNode '%s'",
                       debug().c_str());
            //TODO: throw something
        }
    }
}
Пример #2
0
/**
 * Parse and save predicates.
 */
void ElasticContext::updatePredicates(const std::vector<std::string> &predicateStrings) {
    //If there is already a predicate and thus presumably an index, make sure the request is a subset of what exists
    //That should always be the case, but wrong answers will follow if we are wrong
    if (m_predicates.size() > 0 && dynamic_cast<HashRangeExpression*>(&m_predicates[0]) != NULL && predicateStrings.size() > 0) {
        PlannerDomRoot domRoot(predicateStrings[0].c_str());
        if (!domRoot.isNull()) {
            PlannerDomValue predicateObject = domRoot.rootObject();
            HashRangeExpression *expression = dynamic_cast<HashRangeExpression*>(&m_predicates[0]);
            if (predicateObject.hasKey("predicateExpression")) {
                PlannerDomValue predicateExpression = predicateObject.valueForKey("predicateExpression");
                PlannerDomValue rangesArray = predicateExpression.valueForKey("RANGES");
                for (int ii = 0; ii < rangesArray.arrayLen(); ii++) {
                    PlannerDomValue arrayObject = rangesArray.valueAtIndex(ii);
                    PlannerDomValue rangeStartValue = arrayObject.valueForKey("RANGE_START");
                    PlannerDomValue rangeEndValue = arrayObject.valueForKey("RANGE_END");
                    if (!expression->binarySearch(rangeStartValue.asInt()).isTrue()) {
                        throwFatalException("ElasticContext activate failed because a context already existed with conflicting ranges, conflicting range start is %d", rangeStartValue.asInt());
                    }
                    if (!expression->binarySearch(rangeEndValue.asInt()).isTrue()) {
                        throwFatalException("ElasticContext activate failed because a context already existed with conflicting ranges, conflicting range end is %d", rangeStartValue.asInt());
                    }
                }
            }
        }
    }
    m_predicateStrings = predicateStrings; // retain for possible clone after TRUNCATE TABLE
    TableStreamerContext::updatePredicates(predicateStrings);
}
Пример #3
0
/*
 * Produce a list of StreamPredicateHashRange objects by parsing predicate range strings.
 * Add error messages to errmsg.
 * Return true on success.
 */
bool StreamPredicateList::parseStrings(
        const std::vector<std::string> &predicateStrings,
        std::ostringstream& errmsg,
        std::vector<bool> &predicateDeletes)
{
    bool failed = false;
    for (std::vector<std::string>::const_iterator iter = predicateStrings.begin();
         iter != predicateStrings.end(); ++iter) {
        bool predFailed = false;
        std::string predicateString = *iter;
        if (!predicateString.empty()) {
            try {
                PlannerDomRoot domRoot((*iter).c_str());
                if (!domRoot.isNull()) {
                    PlannerDomValue predicateObject = domRoot.rootObject();

                    predicateDeletes.push_back(predicateObject.valueForKey("triggersDelete").asBool());

                    AbstractExpression *expr = NULL;
                    if (predicateObject.hasKey("predicateExpression")) {
                        expr = AbstractExpression::buildExpressionTree(
                                    predicateObject.valueForKey("predicateExpression"));
                        if (expr != NULL) {
                            // Got ourselves a predicate expression tree!
                            push_back(expr);
                        }
                        else {
                            errmsg << "Predicate JSON generated a NULL expression tree";
                            predFailed = true;
                        }
                    }
                    else {
                        // NULL represents an empty predicate object that should not be evaluated.
                        push_back(NULL);
                    }
                }
                else {
                    errmsg << "Stream predicate JSON document is NULL";
                    predFailed = true;
                }
            }
            catch(std::exception &exc) {
                errmsg << "Exception occurred while parsing stream predicate: " << exc.what();
                predFailed = true;
            }
            if (predFailed) {
                errmsg << std::endl << (*iter) << std::endl;
                failed = true;
            }
        }
        else {
            // NULL predicates are okay.
            push_back(NULL);
        }
    }
    return !failed;
}
Пример #4
0
void
PlanNodeFragment::loadParamsFromJSONObject(PlanNodeFragment *pnf, PlannerDomValue obj)
{
    if (obj.hasKey("PARAMETERS")) {
        PlannerDomValue parametersArray = obj.valueForKey("PARAMETERS");
        for (int i = 0; i < parametersArray.arrayLen(); i++) {
            PlannerDomValue parameterArray = parametersArray.valueAtIndex(i);
            int index = parameterArray.valueAtIndex(0).asInt();
            std::string typeString = parameterArray.valueAtIndex(1).asStr();
            pnf->m_parameters.push_back(std::pair< int, voltdb::ValueType>(index, stringToValue(typeString)));
        }
    }
}
Пример #5
0
void
PlanNodeFragment::loadFromJSONObject(PlannerDomValue obj)
{
    PlannerDomValue executeListArray = obj.valueForKey("EXECUTE_LIST");
    for (int i = 0; i < executeListArray.arrayLen(); i++) {
        m_executionList.push_back(m_idToNodeMap[executeListArray.valueAtIndex(i).asInt()]);
    }

    if (obj.hasKey("PARAMETERS")) {
        PlannerDomValue parametersArray = obj.valueForKey("PARAMETERS");
        for (int i = 0; i < parametersArray.arrayLen(); i++) {
            PlannerDomValue parameterArray = parametersArray.valueAtIndex(i);
            int index = parameterArray.valueAtIndex(0).asInt();
            std::string typeString = parameterArray.valueAtIndex(1).asStr();
            parameters.push_back(std::pair< int, voltdb::ValueType>(index, stringToValue(typeString)));
        }
    }
}