Examples with CorePlan org.voltdb.planner.CorePlan used on opensource projects

Example 1 with CorePlan

use of org.voltdb.planner.CorePlan in project voltdb by VoltDB.

the class AdHocPlannedStatement method fromBuffer.

public static AdHocPlannedStatement fromBuffer(ByteBuffer buf) throws IOException {
    // plan
    CorePlan core = CorePlan.fromBuffer(buf);
    // sql bytes
    int sqlLength = buf.getInt();
    //AS PER ENG-10059, there is a 1MB limit for in List Expression
    if ((sqlLength < 0) || (sqlLength >= 1024 * 1024)) {
        throw new RuntimeException("AdHoc SQL text exceeds the length limitation 1 MB");
    }
    byte[] sql = new byte[sqlLength];
    buf.get(sql);
    // params
    ParameterSet parameterSet = ParameterSet.fromByteBuffer(buf);
    return new AdHocPlannedStatement(sql, core, parameterSet, null);
}

Example 2 with CorePlan

use of org.voltdb.planner.CorePlan in project voltdb by VoltDB.

the class AdHocPlannedStmtBatch method mockStatementBatch.

public static AdHocPlannedStmtBatch mockStatementBatch(long replySiteId, String sql, Object[] extractedValues, VoltType[] paramTypes, Object[] userParams, int partitionParamIndex, Object[] userPartitionKey, byte[] catalogHash, boolean readOnly) {
    // Mock up dummy results from the work request.
    CorePlan core = new CorePlan(new byte[0], partitionParamIndex == -1 ? new byte[20] : null, new byte[20], partitionParamIndex == -1 ? new byte[20] : null, false, readOnly, paramTypes, catalogHash);
    AdHocPlannedStatement s = new AdHocPlannedStatement(sql.getBytes(Constants.UTF8ENCODING), core, extractedValues == null ? ParameterSet.emptyParameterSet() : ParameterSet.fromArrayNoCopy(extractedValues), null);
    List<AdHocPlannedStatement> stmts = new ArrayList<AdHocPlannedStatement>();
    stmts.add(s);
    VoltType partitionParamType = null;
    Object partitionParamValue = null;
    if (userPartitionKey != null) {
        partitionParamValue = userPartitionKey[0];
    } else if (partitionParamIndex > -1) {
        partitionParamValue = userParams[partitionParamIndex];
    }
    if (partitionParamValue != null) {
        partitionParamType = VoltType.typeFromObject(partitionParamValue);
    }
    // Finally, mock up the planned batch.
    AdHocPlannedStmtBatch plannedStmtBatch = new AdHocPlannedStmtBatch(userParams, stmts, partitionParamIndex, partitionParamType, partitionParamValue, null);
    return plannedStmtBatch;
}

Example 3 with CorePlan

use of org.voltdb.planner.CorePlan in project voltdb by VoltDB.

the class PlannerTool method planSql.

public synchronized AdHocPlannedStatement planSql(String sqlIn, StatementPartitioning partitioning, boolean isExplainMode, final Object[] userParams, boolean isSwapTables) {
    CacheUse cacheUse = CacheUse.FAIL;
    if (m_plannerStats != null) {
        m_plannerStats.startStatsCollection();
    }
    boolean hasUserQuestionMark = false;
    boolean wrongNumberParameters = false;
    try {
        if ((sqlIn == null) || (sqlIn.length() == 0)) {
            throw new RuntimeException("Can't plan empty or null SQL.");
        }
        // remove any spaces or newlines
        String sql = sqlIn.trim();
        // if the cases tended to have mostly overlapping queries.
        if (partitioning.isInferred()) {
            // Check the literal cache for a match.
            AdHocPlannedStatement cachedPlan = m_cache.getWithSQL(sqlIn);
            if (cachedPlan != null) {
                cacheUse = CacheUse.HIT1;
                return cachedPlan;
            } else {
                cacheUse = CacheUse.MISS;
            }
        }
        // Reset plan node id counter
        AbstractPlanNode.resetPlanNodeIds();
        //////////////////////
        // PLAN THE STMT
        //////////////////////
        TrivialCostModel costModel = new TrivialCostModel();
        DatabaseEstimates estimates = new DatabaseEstimates();
        QueryPlanner planner = new QueryPlanner(sql, "PlannerTool", "PlannerToolProc", m_database, partitioning, m_hsql, estimates, !VoltCompiler.DEBUG_MODE, AD_HOC_JOINED_TABLE_LIMIT, costModel, null, null, DeterminismMode.FASTER);
        CompiledPlan plan = null;
        String[] extractedLiterals = null;
        String parsedToken = null;
        try {
            if (isSwapTables) {
                planner.planSwapTables();
            } else {
                planner.parse();
            }
            parsedToken = planner.parameterize();
            // check the parameters count
            // check user input question marks with input parameters
            int inputParamsLengh = userParams == null ? 0 : userParams.length;
            if (planner.getAdhocUserParamsCount() != inputParamsLengh) {
                wrongNumberParameters = true;
                if (!isExplainMode) {
                    throw new PlanningErrorException(String.format("Incorrect number of parameters passed: expected %d, passed %d", planner.getAdhocUserParamsCount(), inputParamsLengh));
                }
            }
            hasUserQuestionMark = planner.getAdhocUserParamsCount() > 0;
            // do not put wrong parameter explain query into cache
            if (!wrongNumberParameters && partitioning.isInferred()) {
                // QueryPlanner.
                assert (parsedToken != null);
                extractedLiterals = planner.extractedParamLiteralValues();
                List<BoundPlan> boundVariants = m_cache.getWithParsedToken(parsedToken);
                if (boundVariants != null) {
                    assert (!boundVariants.isEmpty());
                    BoundPlan matched = null;
                    for (BoundPlan boundPlan : boundVariants) {
                        if (boundPlan.allowsParams(extractedLiterals)) {
                            matched = boundPlan;
                            break;
                        }
                    }
                    if (matched != null) {
                        CorePlan core = matched.m_core;
                        ParameterSet params = null;
                        if (planner.compiledAsParameterizedPlan()) {
                            params = planner.extractedParamValues(core.parameterTypes);
                        } else if (hasUserQuestionMark) {
                            params = ParameterSet.fromArrayNoCopy(userParams);
                        } else {
                            // No constants AdHoc queries
                            params = ParameterSet.emptyParameterSet();
                        }
                        AdHocPlannedStatement ahps = new AdHocPlannedStatement(sql.getBytes(Constants.UTF8ENCODING), core, params, null);
                        ahps.setBoundConstants(matched.m_constants);
                        // parameterized plan from the cache does not have exception
                        m_cache.put(sql, parsedToken, ahps, extractedLiterals, hasUserQuestionMark, false);
                        cacheUse = CacheUse.HIT2;
                        return ahps;
                    }
                }
            }
            // If not caching or there was no cache hit, do the expensive full planning.
            plan = planner.plan();
            assert (plan != null);
            if (plan != null && plan.getStatementPartitioning() != null) {
                partitioning = plan.getStatementPartitioning();
            }
        } catch (Exception e) {
            /*
                 * Don't log PlanningErrorExceptions or HSQLParseExceptions, as
                 * they are at least somewhat expected.
                 */
            String loggedMsg = "";
            if (!((e instanceof PlanningErrorException) || (e instanceof HSQLParseException))) {
                logException(e, "Error compiling query");
                loggedMsg = " (Stack trace has been written to the log.)";
            }
            throw new RuntimeException("Error compiling query: " + e.toString() + loggedMsg, e);
        }
        if (plan == null) {
            throw new RuntimeException("Null plan received in PlannerTool.planSql");
        }
        //////////////////////
        // OUTPUT THE RESULT
        //////////////////////
        CorePlan core = new CorePlan(plan, m_catalogHash);
        AdHocPlannedStatement ahps = new AdHocPlannedStatement(plan, core);
        // do not put wrong parameter explain query into cache
        if (!wrongNumberParameters && partitioning.isInferred()) {
            // Note either the parameter index (per force to a user-provided parameter) or
            // the actual constant value of the partitioning key inferred from the plan.
            // Either or both of these two values may simply default
            // to -1 and to null, respectively.
            core.setPartitioningParamIndex(partitioning.getInferredParameterIndex());
            core.setPartitioningParamValue(partitioning.getInferredPartitioningValue());
            assert (parsedToken != null);
            // Again, plans with inferred partitioning are the only ones supported in the cache.
            m_cache.put(sqlIn, parsedToken, ahps, extractedLiterals, hasUserQuestionMark, planner.wasBadPameterized());
        }
        return ahps;
    } finally {
        if (m_plannerStats != null) {
            m_plannerStats.endStatsCollection(m_cache.getLiteralCacheSize(), m_cache.getCoreCacheSize(), cacheUse, -1);
        }
    }
}