Beispiel #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
        }
    }
}
void AbstractPlanNode::loadSortListFromJSONObject(PlannerDomValue obj,
                                                      std::vector<AbstractExpression*> *sortExprs,
                                                      std::vector<SortDirectionType>   *sortDirs) {
    PlannerDomValue sortColumnsArray = obj.valueForKey("SORT_COLUMNS");

    for (int i = 0; i < sortColumnsArray.arrayLen(); i++) {
        PlannerDomValue sortColumn = sortColumnsArray.valueAtIndex(i);
        bool hasDirection = (sortDirs == NULL), hasExpression = (sortExprs == NULL);

        if (sortDirs && sortColumn.hasNonNullKey("SORT_DIRECTION")) {
            hasDirection = true;
            std::string sortDirectionStr = sortColumn.valueForKey("SORT_DIRECTION").asStr();
            sortDirs->push_back(stringToSortDirection(sortDirectionStr));
        }
        if (sortExprs && sortColumn.hasNonNullKey("SORT_EXPRESSION")) {
            hasExpression = true;
            PlannerDomValue exprDom = sortColumn.valueForKey("SORT_EXPRESSION");
            sortExprs->push_back(AbstractExpression::buildExpressionTree(exprDom));
        }

        if (!(hasExpression && hasDirection)) {
            throw SerializableEEException(VOLT_EE_EXCEPTION_TYPE_EEEXCEPTION,
                                          "OrderByPlanNode::loadFromJSONObject:"
                                          " Does not have expression and direction.");
        }
    }
}
Beispiel #3
0
void PartitionByPlanNode::loadFromJSONObject(PlannerDomValue obj)
{
    // Start with the base class.
    AggregatePlanNode::loadFromJSONObject(obj);
    // Read the sort expressions and directions.
    PlannerDomValue sortByColumnArray = obj.valueForKey("SORT_COLUMNS");
    for (int idx = 0; idx < sortByColumnArray.arrayLen(); idx += 1) {
        PlannerDomValue sortColumnValue = sortByColumnArray.valueAtIndex(idx);
        if (sortColumnValue.hasNonNullKey("SORT_EXPRESSION")) {
            PlannerDomValue exprDom = sortColumnValue.valueForKey("SORT_EXPRESSION");
            m_sortExpressions.push_back(AbstractExpression::buildExpressionTree(exprDom));
        } else {
            throw SerializableEEException(VOLT_EE_EXCEPTION_TYPE_EEEXCEPTION,
                                                       "PartitionByPlanNode::loadFromJSONObject:"
                                                       " Missing sort expression.");
        }
        if (sortColumnValue.hasNonNullKey("SORT_DIRECTION")) {
            std::string dirStr = sortColumnValue.valueForKey("SORT_DIRECTION").asStr();
            m_sortDirections.push_back(stringToSortDirection(dirStr));
        } else {
            throw SerializableEEException(VOLT_EE_EXCEPTION_TYPE_EEEXCEPTION,
                                                       "PartitionByPlanNode::loadFromJSONObject:"
                                                       " Missing sort direction.");
        }
    }
}
Beispiel #4
0
void AbstractPlanNode::loadIntArrayFromJSONObject(const char* label,
        PlannerDomValue obj, std::vector<int>& result)
{
    if (obj.hasNonNullKey(label)) {
        PlannerDomValue intArray = obj.valueForKey(label);
        for (int i = 0; i < intArray.arrayLen(); i++) {
            result.push_back(intArray.valueAtIndex(i).asInt());
        }
    }
}
Beispiel #5
0
void InsertPlanNode::loadFromJSONObject(PlannerDomValue obj)
{
    AbstractOperationPlanNode::loadFromJSONObject(obj);
    m_multiPartition = obj.valueForKey("MULTI_PARTITION").asBool();
    if (obj.hasNonNullKey("FIELD_MAP")) {
        PlannerDomValue fieldMap = obj.valueForKey("FIELD_MAP");
        for (int i = 0; i < fieldMap.arrayLen(); ++i) {
          m_fieldMap.push_back(fieldMap.valueAtIndex(i).asInt());
        }
    }
    m_isUpsert = false;
    if (obj.hasNonNullKey("UPSERT")) {
        m_isUpsert = true;
    }
    m_sourceIsPartitioned = false;
    if (obj.hasNonNullKey("SOURCE_IS_PARTITIONED")) {
        m_sourceIsPartitioned = true;
    }
}
Beispiel #6
0
void
AggregatePlanNode::loadFromJSONObject(PlannerDomValue obj)
{
    PlannerDomValue aggregateColumnsArray = obj.valueForKey("AGGREGATE_COLUMNS");
    for (int i = 0; i < aggregateColumnsArray.arrayLen(); i++) {
        PlannerDomValue aggregateColumnValue = aggregateColumnsArray.valueAtIndex(i);
        bool containsType = false;
        bool containsDistinct = false;
        bool containsOutputColumn = false;
        bool containsExpression = false;
        if (aggregateColumnValue.hasNonNullKey("AGGREGATE_TYPE")) {
            containsType = true;
            string aggregateColumnTypeString = aggregateColumnValue.valueForKey("AGGREGATE_TYPE").asStr();
            m_aggregates.push_back(stringToExpression(aggregateColumnTypeString));
        }
        if (aggregateColumnValue.hasNonNullKey("AGGREGATE_DISTINCT")) {
            containsDistinct = true;
            bool distinct = aggregateColumnValue.valueForKey("AGGREGATE_DISTINCT").asInt() == 1;
            m_distinctAggregates.push_back(distinct);
        }
        if (aggregateColumnValue.hasNonNullKey("AGGREGATE_OUTPUT_COLUMN")) {
            containsOutputColumn = true;
            int column = aggregateColumnValue.valueForKey("AGGREGATE_OUTPUT_COLUMN").asInt();
            m_aggregateOutputColumns.push_back(column);
        }
        if (aggregateColumnValue.hasNonNullKey("AGGREGATE_EXPRESSION")) {
            containsExpression = true;
            PlannerDomValue exprDom = aggregateColumnValue.valueForKey("AGGREGATE_EXPRESSION");
            m_aggregateInputExpressions.push_back(AbstractExpression::buildExpressionTree(exprDom));
        }

        if(!(containsType && containsDistinct && containsOutputColumn)) {
            throw SerializableEEException(VOLT_EE_EXCEPTION_TYPE_EEEXCEPTION,
                                      "AggregatePlanNode::loadFromJSONObject:"
                                      " Missing type, distinct, or outputcolumn.");
        }
        if ( ! containsExpression) {
            m_aggregateInputExpressions.push_back(NULL);
        }
    }

    if (obj.hasNonNullKey("GROUPBY_EXPRESSIONS")) {
        PlannerDomValue groupByExpressionsArray = obj.valueForKey("GROUPBY_EXPRESSIONS");
        for (int i = 0; i < groupByExpressionsArray.arrayLen(); i++) {
            m_groupByExpressions.push_back(AbstractExpression::buildExpressionTree(groupByExpressionsArray.valueAtIndex(i)));
        }
    }

    if (obj.hasNonNullKey("PRE_PREDICATE")) {
        m_prePredicate = AbstractExpression::buildExpressionTree(obj.valueForKey("PRE_PREDICATE"));
    }

    if (obj.hasNonNullKey("POST_PREDICATE")) {
        m_postPredicate = AbstractExpression::buildExpressionTree(obj.valueForKey("POST_PREDICATE"));
    }
}
// Load boolean array from JSON object.
// In IndexScanPlanNode (indexscannode.h and indexscannode.cpp),
//   we added a boolean vector "m_compare_not_distinct"
//   to indicate whether null values should be skipped for each search key column.
// This function is used to deseralize that boolean vector. (ENG-11096)
void AbstractPlanNode::loadBooleanArrayFromJSONObject(const char* label,
                                                      PlannerDomValue obj,
                                                      std::vector<bool>& result)
{
    if (obj.hasNonNullKey(label)) {
        PlannerDomValue stringArray = obj.valueForKey(label);
        int len = stringArray.arrayLen();
        for (int i = 0; i < len; ++i) {
            result.push_back(stringArray.valueAtIndex(i).asBool());
        }
    }
}
Beispiel #8
0
void AbstractPlanNode::OwningExpressionVector::loadExpressionArrayFromJSONObject(const char* label,
                                                                                 PlannerDomValue obj)
{
    clear();
    if ( ! obj.hasNonNullKey(label)) {
        return;
    }
    PlannerDomValue arrayObj = obj.valueForKey(label);
    for (int i = 0; i < arrayObj.arrayLen(); i++) {
        AbstractExpression *expr = AbstractExpression::buildExpressionTree(arrayObj.valueAtIndex(i));
        push_back(expr);
    }
}