/* * Serialize more tuples to one or more output streams. * Returns a long for the remaining tuple count, -1 for an error. * Streams an int position array through the reused result buffer. * Class: org_voltdb_jni_ExecutionEngine * Method: nativeTableStreamSerializeMore * Signature: (JII[B)J; */ SHAREDLIB_JNIEXPORT jlong JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeTableStreamSerializeMore (JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId, jint streamType, jbyteArray serialized_buffers) { VOLT_DEBUG("nativeTableStreamSerializeMore in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); jsize length = env->GetArrayLength(serialized_buffers); VOLT_DEBUG("nativeTableStreamSerializeMore: deserializing %d buffer bytes ...", (int) length); jbyte *bytes = env->GetByteArrayElements(serialized_buffers, NULL); ReferenceSerializeInput serialize_in(bytes, length); try { try { voltdb::TableStreamType tst = static_cast<voltdb::TableStreamType>(streamType); jlong tuplesRemaining = engine->tableStreamSerializeMore(tableId, tst, serialize_in); return tuplesRemaining; } catch (const SQLException &e) { throwFatalException("%s", e.message().c_str()); } } catch (const FatalException &e) { topend->crashVoltDB(e); } // Won't get here. return TABLE_STREAM_SERIALIZATION_ERROR; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeGetUSOForExportTable * Signature: (JLjava/lang/String;)[J */ SHAREDLIB_JNIEXPORT jlongArray JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeGetUSOForExportTable (JNIEnv *env, jobject obj, jlong engine_ptr, jbyteArray tableSignature) { VOLT_DEBUG("nativeGetUSOForExportTable in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); jbyte *signatureChars = env->GetByteArrayElements(tableSignature, NULL); std::string signature(reinterpret_cast<char *>(signatureChars), env->GetArrayLength(tableSignature)); env->ReleaseByteArrayElements(tableSignature, signatureChars, JNI_ABORT); try { jlong data[2]; size_t ackOffset; int64_t seqNo; engine->getUSOForExportTable(ackOffset, seqNo, signature); data[0] = ackOffset; data[1] = seqNo; jlongArray retval = env->NewLongArray(2); env->SetLongArrayRegion(retval, 0, 2, data); return retval; } catch (FatalException e) { topend->crashVoltDB(e); } return NULL; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeTableStreamSerializeMore * Signature: (JJIIII)I */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeTableStreamSerializeMore (JNIEnv *env, jobject obj, jlong engine_ptr, jlong bufferPtr, jint offset, jint length, jint tableId, jint streamType) { VOLT_DEBUG("nativeTableStreamSerializeMore in C++ called"); ReferenceSerializeOutput out(reinterpret_cast<char*>(bufferPtr) + offset, length - offset); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { try { return engine->tableStreamSerializeMore( &out, tableId, static_cast<voltdb::TableStreamType>(streamType)); } catch (SQLException e) { throwFatalException("%s", e.message().c_str()); } } catch (FatalException e) { topend->crashVoltDB(e); } return 0; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeExportAction * * @param ackAction true if this call contains an ack * @param pollAction true if this call requests a poll * @param syncAction true if the stream offset being set for a table * @param ackOffset if acking, the universal stream offset being acked/released * @param tableSignature Signature of the table to which the Export action applies * * @return the universal stream offset for the last octet in any * returned poll results (returned via the query results buffer). On * any error this will be less than 0. For any call with no * pollAction, any value >= 0 may be ignored. */ SHAREDLIB_JNIEXPORT jlong JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeExportAction (JNIEnv *env, jobject obj, jlong engine_ptr, jboolean syncAction, jlong ackOffset, jlong seqNo, jbyteArray tableSignature) { VOLT_DEBUG("nativeExportAction in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); jbyte *signatureChars = env->GetByteArrayElements(tableSignature, NULL); std::string signature(reinterpret_cast<char *>(signatureChars), env->GetArrayLength(tableSignature)); env->ReleaseByteArrayElements(tableSignature, signatureChars, JNI_ABORT); try { try { engine->resetReusedResultOutputBuffer(); return engine->exportAction(syncAction, static_cast<int64_t>(ackOffset), static_cast<int64_t>(seqNo), signature); } catch (SQLException e) { throwFatalException("%s", e.message().c_str()); } } catch (FatalException e) { topend->crashVoltDB(e); } return 0; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeActivateTableStream * Signature: (JIIIJ[B)Z */ SHAREDLIB_JNIEXPORT jboolean JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeActivateTableStream( JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId, jint streamType, jlong undoToken, jbyteArray serialized_predicates) { VOLT_DEBUG("nativeActivateTableStream in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); // deserialize predicates. jsize length = env->GetArrayLength(serialized_predicates); VOLT_DEBUG("deserializing %d predicate bytes ...", (int) length); jbyte *bytes = env->GetByteArrayElements(serialized_predicates, NULL); ReferenceSerializeInput serialize_in(bytes, length); try { try { voltdb::TableStreamType tableStreamType = static_cast<voltdb::TableStreamType>(streamType); bool success = engine->activateTableStream(tableId, tableStreamType, undoToken, serialize_in); env->ReleaseByteArrayElements(serialized_predicates, bytes, JNI_ABORT); VOLT_DEBUG("deserialized predicates (success=%d)", (int)success); return success; } catch (SerializableEEException &e) { engine->resetReusedResultOutputBuffer(); e.serialize(engine->getExceptionOutputSerializer()); } } catch (const FatalException& e) { topend->crashVoltDB(e); } return false; }
/** * Serialize the result temporary table. * @param engine_ptr the VoltDBEngine pointer * @param table_id Id of the table to be serialized * @return serialized temporary table */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeSerializeTable( JNIEnv *env, jobject obj, jlong engine_ptr, jint table_id, jobject output_buffer, jint output_capacity) { //VOLT_DEBUG("nativeSerializeTable() start"); VoltDBEngine *engine = castToEngine(engine_ptr); if (engine == NULL) { VOLT_ERROR("The VoltDBEngine pointer is null!"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated void* data = env->GetDirectBufferAddress(output_buffer); ReferenceSerializeOutput out(data, output_capacity); bool success = engine->serializeTable(table_id, &out); if (!success) return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; else return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } catch (const FatalException &e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/** * Sets (or re-sets) the buffer shared between java and the EE. This is for reducing * cost of GetDirectBufferAddress(). * @param pointer the VoltDBEngine pointer * @param parameter_buffer direct byte buffer to be set * @param m_parameterBuffersize size of the buffer * @param result_buffer direct byte buffer to be set * @param result_buffer_size size of the buffer * @param exception_buffer direct byte buffer to be set * @param exception_buffer_size size of the buffer * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeSetBuffers (JNIEnv *env, jobject obj, jlong engine_ptr, jobject parameter_buffer, jint parameter_buffer_size, jobject result_buffer, jint result_buffer_size, jobject exception_buffer, jint exception_buffer_size) { VOLT_DEBUG("nativeSetBuffers() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated char *parameterBuffer = reinterpret_cast<char*>( env->GetDirectBufferAddress(parameter_buffer)); int parameterBufferCapacity = parameter_buffer_size; char *reusedResultBuffer = reinterpret_cast<char*>( env->GetDirectBufferAddress(result_buffer)); int reusedResultBufferCapacity = result_buffer_size; char *exceptionBuffer = reinterpret_cast<char*>( env->GetDirectBufferAddress(exception_buffer)); int exceptionBufferCapacity = exception_buffer_size; engine->setBuffers(parameterBuffer, parameterBufferCapacity, reusedResultBuffer, reusedResultBufferCapacity, exceptionBuffer, exceptionBufferCapacity); } catch (const FatalException &e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeHashinate * Signature: (JI)I */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeHashinate(JNIEnv *env, jobject obj, jlong engine_ptr) { VOLT_DEBUG("nativeHashinate in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); assert(engine); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated NValueArray& params = engine->getParameterContainer(); Pool *stringPool = engine->getStringPool(); deserializeParameterSet(engine->getParameterBuffer(), engine->getParameterBufferCapacity(), params, engine->getStringPool()); HashinatorType hashinatorType = static_cast<HashinatorType>(voltdb::ValuePeeker::peekAsInteger(params[1])); boost::scoped_ptr<TheHashinator> hashinator; const char *configValue = static_cast<const char*>(voltdb::ValuePeeker::peekObjectValue(params[2])); switch (hashinatorType) { case HASHINATOR_LEGACY: hashinator.reset(LegacyHashinator::newInstance(configValue)); break; case HASHINATOR_ELASTIC: hashinator.reset(ElasticHashinator::newInstance(configValue)); break; default: return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } int retval = hashinator->hashinate(params[0]); stringPool->purge(); return retval; } catch (const FatalException &e) { std::cout << "HASHINATE ERROR: " << e.m_reason << std::endl; return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
TEST_F(PersistentTableTest, TruncateTableTest) { VoltDBEngine* engine = getEngine(); engine->loadCatalog(0, catalogPayload()); PersistentTable *table = dynamic_cast<PersistentTable*>( engine->getTable("T")); ASSERT_NE(NULL, table); const int tuplesToInsert = 10; (void) tuplesToInsert; // to make compiler happy ASSERT_EQ(1, table->allocatedBlockCount()); bool addTuples = tableutil::addRandomTuples(table, tuplesToInsert); if(!addTuples) { assert(!"Failed adding random tuples"); } size_t blockCount = table->allocatedBlockCount(); table = dynamic_cast<PersistentTable*>(engine->getTable("T")); ASSERT_NE(NULL, table); ASSERT_EQ(blockCount, table->allocatedBlockCount()); addTuples = tableutil::addRandomTuples(table, tuplesToInsert); if(!addTuples) { assert(!"Failed adding random tuples"); } table->truncateTable(engine); // refresh table pointer by fetching the table from catalog as in truncate old table // gets replaced with new cloned empty table table = dynamic_cast<PersistentTable*>(engine->getTable("T")); ASSERT_NE(NULL, table); ASSERT_EQ(1, table->allocatedBlockCount()); }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeLoadPlanFragment * Signature: (JJ[B)I */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeLoadPlanFragment ( JNIEnv *env, jobject obj, jlong engine_ptr, jbyteArray plan) { VOLT_DEBUG("nativeUnloadPlanFragment() start"); // setup VoltDBEngine *engine = castToEngine(engine_ptr); assert(engine); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); // convert java plan string to stdc++ string plan jbyte *str = env->GetByteArrayElements(plan, NULL); assert(str); // get the buffer to write results to engine->resetReusedResultOutputBuffer(); ReferenceSerializeOutput* out = engine->getResultOutputSerializer(); // output from the engine's loadFragment method int64_t fragId = 0; bool wasHit = 0; int64_t cacheSize = 0; // load int result = 1; try { result = engine->loadFragment(reinterpret_cast<char *>(str), env->GetArrayLength(plan), fragId, wasHit, cacheSize); } catch (FatalException e) { topend->crashVoltDB(e); } assert((result == 1) || (fragId != 0)); // release plan memory env->ReleaseByteArrayElements(plan, str, JNI_ABORT); // write results back to java out->writeLong(fragId); out->writeBool(wasHit); out->writeLong(cacheSize); if (result == 1) return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; else return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeTick * Signature: (JJJ)V * * Called roughly every 1 second by the Java Runtime to allow the EE to do * periodic non-transactional work. * * @param env Pointer to the JNIEnv for this thread * @param obj Pointer to the object on which this method was called * @param engine_ptr Pointer to a VoltDBEngine instance * @param timeInMillis The current java timestamp (System.currentTimeMillis()); * @param lastCommittedSpHandle The id of the last committed transaction. */ SHAREDLIB_JNIEXPORT void JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeTick (JNIEnv *env, jobject obj, jlong engine_ptr, jlong timeInMillis, jlong lastCommittedSpHandle) { VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated engine->tick(timeInMillis, lastCommittedSpHandle); } catch (FatalException e) { topend->crashVoltDB(e); } }
void AbstractOperationPlanNode::loadFromJSONObject(PlannerDomValue obj) { m_target_table_name = obj.valueForKey("TARGET_TABLE_NAME").asStr(); 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 } }
ParameterValueExpression::ParameterValueExpression(int value_idx) : AbstractExpression(EXPRESSION_TYPE_VALUE_PARAMETER), m_valueIdx(value_idx), m_paramValue() { VOLT_TRACE("ParameterValueExpression %d", value_idx); ExecutorContext* context = ExecutorContext::getExecutorContext(); VoltDBEngine* engine = context->getEngine(); assert(engine != NULL); NValueArray& params = engine->getParameterContainer(); assert(value_idx < params.size()); m_paramValue = ¶ms[value_idx]; };
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeActivateTableStream * Signature: (JII)Z */ SHAREDLIB_JNIEXPORT jboolean JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeActivateTableStream (JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId, jint streamType) { VOLT_DEBUG("nativeActivateTableStream in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { return engine->activateTableStream(tableId, static_cast<voltdb::TableStreamType>(streamType)); } catch (FatalException e) { topend->crashVoltDB(e); } return false; }
/** * Releases all resources held in the execution engine. * @param engine_ptr the VoltDBEngine pointer to be destroyed * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeDestroy( JNIEnv *env, jobject obj, jlong engine_ptr) { VoltDBEngine *engine = castToEngine(engine_ptr); static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated if (engine == NULL) { return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } delete engine; return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeQuiesce * Signature: (JJ)V * * Called to instruct the EE to reach an idle steady state. */ SHAREDLIB_JNIEXPORT void JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeQuiesce (JNIEnv *env, jobject obj, jlong engine_ptr, jlong lastCommittedTxnId) { VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { // JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); engine->quiesce(lastCommittedTxnId); } catch (FatalException e) { topend->crashVoltDB(e); } }
void AbstractPlanNode::setOutputTable(Table* table) { PersistentTable* persistentTable = dynamic_cast<PersistentTable*>(table); if (persistentTable) { VoltDBEngine* engine = ExecutorContext::getEngine(); TableCatalogDelegate* tcd = engine->getTableDelegate(persistentTable->name()); m_outputTable.setTable(tcd); } else { TempTable* tempTable = dynamic_cast<TempTable*>(table); assert(tempTable); m_outputTable.setTable(tempTable); } }
/** * Initializes the execution engine with given parameter. * @param enginePtr the VoltDBEngine pointer to be initialized * @param clusterId id of the cluster the execution engine belongs to * @param nodeId this id will be set to the execution engine * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeInitialize( JNIEnv *env, jobject obj, jlong enginePtr, jint clusterIndex, jlong siteId, jint partitionId, jint hostId, jbyteArray hostname, jlong tempTableMemory, jint hashinatorType, jbyteArray hashinatorConfig) { VOLT_DEBUG("nativeInitialize() start"); VoltDBEngine *engine = castToEngine(enginePtr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { VOLT_ERROR("engine_ptr was NULL or invalid pointer"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated jbyte *hostChars = env->GetByteArrayElements( hostname, NULL); std::string hostString(reinterpret_cast<char*>(hostChars), env->GetArrayLength(hostname)); env->ReleaseByteArrayElements( hostname, hostChars, JNI_ABORT); jbyte *hashinatorConfigData = env->GetByteArrayElements(hashinatorConfig, NULL); // initialization is separated from constructor so that constructor // never fails. VOLT_DEBUG("calling initialize..."); bool success = engine->initialize(clusterIndex, siteId, partitionId, hostId, hostString, tempTableMemory, (HashinatorType)hashinatorType, (char*)hashinatorConfigData); env->ReleaseByteArrayElements( hashinatorConfig, hashinatorConfigData, JNI_ABORT); if (success) { VOLT_DEBUG("initialize succeeded"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } else { throwFatalException("initialize failed"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } } catch (const FatalException &e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/** * Class: org_voltdb_jni_ExecutionEngine * Method: nativeGetStats * Signature: (I[I)Z * * Called to retrieve statistics * * @param env Pointer to the JNIEnv for this thread * @param obj Pointer to the object on which this method was called * @param engine_ptr Pointer to a VoltDBEngine instance * @param selector Ordinal value from StatisticsSelectorType enum indicating the type of stats to retrieve * @param locatorsArray Java array of CatalogIds indicating what set of sources should the statistics be retrieved from. * @return Number of result tables, 0 on no results, -1 on failure. */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeGetStats(JNIEnv *env, jobject obj, jlong pointer, jint selector, jintArray locatorsArray, jboolean jinterval, jlong now) { VoltDBEngine *engine = castToEngine(pointer); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); /* * Can't use the standard JNI EE error code here because this method * actually uses that integer to indicate the number of result tables. */ int result = -1; //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); engine->resetReusedResultOutputBuffer(); /* * Retrieve locators if any */ int *locators = NULL; int numLocators = 0; if (locatorsArray != NULL) { locators = env->GetIntArrayElements(locatorsArray, NULL); if (locators == NULL) { env->ExceptionDescribe(); return JNI_FALSE; } numLocators = env->GetArrayLength(locatorsArray); if (env->ExceptionCheck()) { env->ExceptionDescribe(); env->ReleaseIntArrayElements(locatorsArray, locators, JNI_ABORT); return JNI_FALSE; } } const bool interval = jinterval == JNI_TRUE ? true : false; try { result = engine->getStats(static_cast<int>(selector), locators, numLocators, interval, now); } catch (FatalException e) { topend->crashVoltDB(e); } env->ReleaseIntArrayElements(locatorsArray, locators, JNI_ABORT); return static_cast<jint>(result); }
void SwapTablesPlanNode::loadFromJSONObject(PlannerDomValue obj) { AbstractOperationPlanNode::loadFromJSONObject(obj); m_otherTargetTableName = obj.valueForKey("OTHER_TARGET_TABLE_NAME").asStr(); loadStringArrayFromJSONObject("INDEXES", obj, m_theIndexes); loadStringArrayFromJSONObject("OTHER_INDEXES", obj, m_otherIndexes); VoltDBEngine* engine = ExecutorContext::getEngine(); m_otherTcd = engine->getTableDelegate(m_otherTargetTableName); if ( ! m_otherTcd) { VOLT_ERROR("Failed to retrieve second target table from execution engine for PlanNode: %s", debug().c_str()); //TODO: throw something } }
/** * Initializes the execution engine with given parameter. * @param enginePtr the VoltDBEngine pointer to be initialized * @param clusterId id of the cluster the execution engine belongs to * @param nodeId this id will be set to the execution engine * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeInitialize( JNIEnv *env, jobject obj, jlong enginePtr, jint clusterIndex, jlong siteId, jint partitionId, jint hostId, jstring hostname, jlong tempTableMemory, jint totalPartitions) { VOLT_DEBUG("nativeInitialize() start"); VoltDBEngine *engine = castToEngine(enginePtr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { VOLT_ERROR("engine_ptr was NULL or invalid pointer"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated const char *hostChars = env->GetStringUTFChars( hostname, NULL); std::string hostString(hostChars); env->ReleaseStringUTFChars( hostname, hostChars); // initialization is separated from constructor so that constructor // never fails. VOLT_DEBUG("calling initialize..."); bool success = engine->initialize(clusterIndex, siteId, partitionId, hostId, hostString, tempTableMemory, totalPartitions); if (success) { VOLT_DEBUG("initialize succeeded"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } else { throwFatalException("initialize failed"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } } catch (FatalException e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeSetLogLevels * Signature: (JJ)Z */ SHAREDLIB_JNIEXPORT jboolean JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeSetLogLevels (JNIEnv *env, jobject obj, jlong engine_ptr, jlong logLevels) { VOLT_DEBUG("nativeSetLogLevels in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated if (engine) { engine->getLogManager()->setLogLevels(logLevels); } return JNI_FALSE; } catch (FatalException e) { topend->crashVoltDB(e); } return false; }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeTableHashCode * Signature: (JI)J */ SHAREDLIB_JNIEXPORT jlong JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeTableHashCode (JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId) { VOLT_DEBUG("nativeTableHashCode in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { try { return engine->tableHashCode(tableId); } catch (SQLException e) { throwFatalException("%s", e.message().c_str()); } } catch (FatalException e) { topend->crashVoltDB(e); } return 0; }
/** * Release the undo token * @returns JNI_TRUE on success. JNI_FALSE otherwise. */ SHAREDLIB_JNIEXPORT jboolean JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeReleaseUndoToken (JNIEnv *env, jobject obj, jlong engine_ptr, jlong undoToken) { VOLT_DEBUG("nativeReleaseUndoToken in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated if (engine) { engine->releaseUndoToken(undoToken); return JNI_TRUE; } } catch (FatalException e) { topend->crashVoltDB(e); } return JNI_FALSE; }
void AbstractPlanNode::setInputTables(const vector<Table*>& val) { size_t ii = val.size(); m_inputTables.resize(ii); while (ii--) { PersistentTable* persistentTable = dynamic_cast<PersistentTable*>(val[ii]); if (persistentTable) { VoltDBEngine* engine = ExecutorContext::getEngine(); assert(engine); TableCatalogDelegate* tcd = engine->getTableDelegate(persistentTable->name()); m_inputTables[ii].setTable(tcd); } else { TempTable* tempTable = dynamic_cast<TempTable*>(val[ii]); assert(tempTable); m_inputTables[ii].setTable(tempTable); } } }
SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeAntiCacheMergeBlocks ( JNIEnv *env, jobject obj, jlong engine_ptr, jint tableId) { int retval = org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; VOLT_DEBUG("nativeAntiCacheMergeBlocks() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) return (retval); try { retval = engine->antiCacheMergeBlocks(static_cast<int32_t>(tableId)); } catch (FatalException e) { topend->crashVoltDB(e); } return (retval); }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeProcessRecoveryMessage * Signature: (JJII)V */ SHAREDLIB_JNIEXPORT void JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeProcessRecoveryMessage (JNIEnv *env, jobject obj, jlong engine_ptr, jlong buffer_ptr, jint offset, jint remaining) { //ProfilerEnable(); VOLT_DEBUG("nativeProcessRecoveryMessage in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); char *data = reinterpret_cast<char*>(buffer_ptr) + offset; try { if (data == NULL) { throwFatalException("Failed to get byte array elements of recovery message"); } ReferenceSerializeInput input(data, remaining); RecoveryProtoMsg message(&input); return engine->processRecoveryMessage(&message); } catch (FatalException e) { topend->crashVoltDB(e); } //ProfilerDisable(); }
/* * Class: org_voltdb_jni_ExecutionEngine * Method: nativeHashinate * Signature: (JI)I */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeHashinate(JNIEnv *env, jobject obj, jlong engine_ptr, jint partitionCount) { VOLT_DEBUG("nativeHashinate in C++ called"); VoltDBEngine *engine = castToEngine(engine_ptr); assert(engine); try { updateJNILogProxy(engine); //JNIEnv pointer can change between calls, must be updated NValueArray& params = engine->getParameterContainer(); Pool *stringPool = engine->getStringPool(); deserializeParameterSet(engine->getParameterBuffer(), engine->getParameterBufferCapacity(), params, engine->getStringPool()); int retval = voltdb::TheHashinator::hashinate(params[0], partitionCount); stringPool->purge(); return retval; } catch (FatalException e) { std::cout << "HASHINATE ERROR: " << e.m_reason << std::endl; return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/** * Load the system catalog for this engine. * @param engine_ptr the VoltDBEngine pointer * @param serialized_catalog the root catalog object serialized as text strings. * human-readable text strings separated by line feeds. * @return error code */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeUpdateCatalog( JNIEnv *env, jobject obj, jlong engine_ptr, jlong timestamp, jbyteArray catalog_diffs) { VOLT_DEBUG("nativeUpdateCatalog() start"); VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { VOLT_ERROR("engine_ptr was NULL or invalid pointer"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); //copy to std::string. utf_chars may or may not by a copy of the string jbyte* utf_chars = env->GetByteArrayElements(catalog_diffs, NULL); string str(reinterpret_cast<char*>(utf_chars), env->GetArrayLength(catalog_diffs)); env->ReleaseByteArrayElements(catalog_diffs, utf_chars, JNI_ABORT); VOLT_DEBUG("calling loadCatalog..."); try { bool success = engine->updateCatalog( timestamp, str); if (success) { VOLT_DEBUG("updateCatalog succeeded"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } } catch (const SerializableEEException &e) { engine->resetReusedResultOutputBuffer(); e.serialize(engine->getExceptionOutputSerializer()); } catch (const FatalException &fe) { if (topend != NULL) { topend->crashVoltDB(fe); } } VOLT_ERROR("updateCatalog failed"); return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }
/** * This method is called to initially load table data. * @param pointer the VoltDBEngine pointer * @param table_id catalog ID of the table * @param serialized_table the table data to be loaded */ SHAREDLIB_JNIEXPORT jint JNICALL Java_org_voltdb_jni_ExecutionEngine_nativeLoadTable ( JNIEnv *env, jobject obj, jlong engine_ptr, jint table_id, jbyteArray serialized_table, jlong spHandle, jlong lastCommittedSpHandle) { VoltDBEngine *engine = castToEngine(engine_ptr); Topend *topend = static_cast<JNITopend*>(engine->getTopend())->updateJNIEnv(env); if (engine == NULL) { return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; } //JNIEnv pointer can change between calls, must be updated updateJNILogProxy(engine); VOLT_DEBUG("loading table %d in C++...", table_id); // deserialize dependency. jsize length = env->GetArrayLength(serialized_table); VOLT_DEBUG("deserializing %d bytes ...", (int) length); jbyte *bytes = env->GetByteArrayElements(serialized_table, NULL); ReferenceSerializeInput serialize_in(bytes, length); try { try { bool success = engine->loadTable(table_id, serialize_in, spHandle, lastCommittedSpHandle); env->ReleaseByteArrayElements(serialized_table, bytes, JNI_ABORT); VOLT_DEBUG("deserialized table"); if (success) return org_voltdb_jni_ExecutionEngine_ERRORCODE_SUCCESS; } catch (SerializableEEException &e) { engine->resetReusedResultOutputBuffer(); e.serialize(engine->getExceptionOutputSerializer()); } } catch (FatalException e) { topend->crashVoltDB(e); } return org_voltdb_jni_ExecutionEngine_ERRORCODE_ERROR; }