HDFS_Scan_RetCode HdfsScan::stop() { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsScan::stop() called."); if (initJNIEnv() != JOI_OK) return HDFS_SCAN_ERROR_STOP_PARAM; if (hdfsStats_ != NULL) hdfsStats_->getHdfsTimer().start(); tsRecentJMFromJNI = JavaMethods_[JM_STOP].jm_full_name; jenv_->CallVoidMethod(javaObj_, JavaMethods_[JM_STOP].methodID); if (hdfsStats_ != NULL) { hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop()); hdfsStats_->incHdfsCalls(); } if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsScan::stop()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_SCAN_ERROR_STOP_EXCEPTION; } return HDFS_SCAN_OK; }
OFR_RetCode OrcFileReader::open(const char* path) { QRLogger::log(CAT_SQL_HDFS_ORC_FILE_READER, LL_DEBUG, "OrcFileReader::open(%s) called.", path); if (initJNIEnv() != JOI_OK) return OFR_ERROR_OPEN_PARAM; jstring js_path = jenv_->NewStringUTF(path); if (js_path == NULL) { jenv_->PopLocalFrame(NULL); return OFR_ERROR_OPEN_PARAM; } // String open(java.lang.String); tsRecentJMFromJNI = JavaMethods_[JM_OPEN].jm_full_name; jstring jresult = (jstring)jenv_->CallObjectMethod(javaObj_, JavaMethods_[JM_OPEN].methodID, js_path); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "OrcFileReader::open()"); jenv_->PopLocalFrame(NULL); return OFR_ERROR_OPEN_EXCEPTION; } jenv_->PopLocalFrame(NULL); return OFR_OK; }
HDFS_Scan_RetCode HdfsScan::trafHdfsRead(int retArray[], short arrayLen) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsScan::trafHdfsRead() called."); if (initJNIEnv() != JOI_OK) return HDFS_SCAN_ERROR_TRAF_HDFS_READ_PARAM; if (hdfsStats_ != NULL) hdfsStats_->getHdfsTimer().start(); tsRecentJMFromJNI = JavaMethods_[JM_TRAF_HDFS_READ].jm_full_name; jintArray j_retArray = (jintArray)jenv_->CallObjectMethod(javaObj_, JavaMethods_[JM_TRAF_HDFS_READ].methodID); if (hdfsStats_ != NULL) { hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop()); hdfsStats_->incHdfsCalls(); } if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsScan::setScanRanges()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_SCAN_ERROR_TRAF_HDFS_READ_EXCEPTION; } if (j_retArray == NULL) return HDFS_SCAN_EOR; short retArrayLen = jenv_->GetArrayLength(j_retArray); ex_assert(retArrayLen == arrayLen, "HdfsScan::trafHdfsRead() InternalError: retArrayLen != arrayLen"); jenv_->GetIntArrayRegion(j_retArray, 0, 4, retArray); return HDFS_SCAN_OK; }
HVC_RetCode HiveClient_JNI::initConnection() { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HiveClient_JNI::initConnection(%s) called."); if (initJNIEnv() != JOI_OK) return HVC_ERROR_INIT_PARAM; if (init() != HVC_OK) return HVC_ERROR_INIT_PARAM; tsRecentJMFromJNI = JavaMethods_[JM_INIT].jm_full_name; jboolean jresult = jenv_->CallBooleanMethod(javaObj_, JavaMethods_[JM_INIT].methodID); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::initConnection()"); jenv_->PopLocalFrame(NULL); return HVC_ERROR_INIT_EXCEPTION; } if (jresult == false) { logError(CAT_SQL_HDFS, "HiveClient_JNI::initConnection()", getLastError()); jenv_->PopLocalFrame(NULL); return HVC_ERROR_INIT_EXCEPTION; } isConnected_ = TRUE; jenv_->PopLocalFrame(NULL); return HVC_OK; }
HDFS_Client_RetCode HdfsClient::hdfsListDirectory(const char *pathStr, HDFS_FileInfo **hdfsFileInfo, int *numFiles) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsListDirectory(%s) called.", pathStr); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_HDFS_LIST_DIR_PARAM; jstring js_pathStr = jenv_->NewStringUTF(pathStr); if (js_pathStr == NULL) { jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_LIST_DIR_PARAM; } jlong jniObj = (long)this; tsRecentJMFromJNI = JavaMethods_[JM_HDFS_LIST_DIRECTORY].jm_full_name; jint retNumFiles = jenv_->CallIntMethod(javaObj_, JavaMethods_[JM_HDFS_LIST_DIRECTORY].methodID, js_pathStr, jniObj); if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsClient::hdfsListDirectory()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_LIST_DIR_EXCEPTION; } *numFiles = retNumFiles; *hdfsFileInfo = hdfsFileInfo_; jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_OK; }
HDFS_Client_RetCode HdfsClient::hdfsExists( const NAString& uldPath, NABoolean & exist) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsExists(%s) called.", uldPath.data()); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_HDFS_EXISTS_PARAM; if (getInstance() == NULL) return HDFS_CLIENT_ERROR_HDFS_EXISTS_PARAM; jstring js_UldPath = jenv_->NewStringUTF(uldPath.data()); if (js_UldPath == NULL) { jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_EXISTS_PARAM; } tsRecentJMFromJNI = JavaMethods_[JM_HDFS_EXISTS].jm_full_name; jboolean jresult = jenv_->CallStaticBooleanMethod(javaClass_, JavaMethods_[JM_HDFS_EXISTS].methodID, js_UldPath); exist = jresult; if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsClient::hdfsExists()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_EXISTS_EXCEPTION; } jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_OK; }
HDFS_Client_RetCode HdfsClient::hdfsCleanUnloadPath( const NAString& uldPath) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsCleanUnloadPath(%s) called.", uldPath.data()); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_HDFS_CLEANUP_PARAM; if (getInstance() == NULL) return HDFS_CLIENT_ERROR_HDFS_CLEANUP_PARAM; jstring js_UldPath = jenv_->NewStringUTF(uldPath.data()); if (js_UldPath == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_CLEANUP_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_CLEANUP_PARAM; } tsRecentJMFromJNI = JavaMethods_[JM_HDFS_CLEAN_UNLOAD_PATH].jm_full_name; jboolean jresult = jenv_->CallStaticBooleanMethod(javaClass_, JavaMethods_[JM_HDFS_CLEAN_UNLOAD_PATH].methodID, js_UldPath); if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsClient::hdfsCleanUnloadPath()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_CLEANUP_EXCEPTION; } jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_OK; }
OFR_RetCode OrcFileReader::close() { QRLogger::log(CAT_SQL_HDFS_ORC_FILE_READER, LL_DEBUG, "OrcFileReader::close() called."); if (initJNIEnv() != JOI_OK) return OFR_ERROR_GETPOS_EXCEPTION; // String close(); tsRecentJMFromJNI = JavaMethods_[JM_CLOSE].jm_full_name; jstring jresult = (jstring)jenv_->CallObjectMethod(javaObj_, JavaMethods_[JM_CLOSE].methodID); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "OrcFileReader::close()"); jenv_->PopLocalFrame(NULL); return OFR_ERROR_CLOSE_EXCEPTION; } if (jresult!=NULL) { logError(CAT_SQL_HDFS_ORC_FILE_READER, "OrcFileReader::close()", jresult); jenv_->PopLocalFrame(NULL); return OFR_ERROR_CLOSE_EXCEPTION; } jenv_->PopLocalFrame(NULL); return OFR_OK; }
HDFS_Client_RetCode HdfsClient::hdfsCreateDirectory(const NAString &dirName) { QRLogger::log(CAT_SQL_HBASE, LL_DEBUG, "Enter HDFSClient_JNI::createDirectory() called."); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_CREATE_DIRECTORY_PARAM; if (getInstance() == NULL) return HDFS_CLIENT_ERROR_CREATE_DIRECTORY_PARAM; jstring js_dirName = jenv_->NewStringUTF(dirName.data()); if (js_dirName == NULL) { jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_CREATE_DIRECTORY_PARAM; } tsRecentJMFromJNI = JavaMethods_[JM_HDFS_CREATE_DIRECTORY].jm_full_name; jstring jresult = (jstring)jenv_->CallStaticObjectMethod(javaClass_, JavaMethods_[JM_HDFS_CREATE_DIRECTORY].methodID, js_dirName); if (jenv_->ExceptionCheck()) { getExceptionDetails(jenv_); logError(CAT_SQL_HBASE, __FILE__, __LINE__); logError(CAT_SQL_HBASE, "HDFSClient_JNI::hdfsCreateDirectory()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_CREATE_DIRECTORY_EXCEPTION; } if (jresult == false) { logError(CAT_SQL_HDFS, "HdfsClient::hdfsCreateDirectory()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_DELETE_PATH_EXCEPTION; } jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_OK; }
OFR_RetCode OrcFileReader::getPosition(Int64& pos) { QRLogger::log(CAT_SQL_HDFS_ORC_FILE_READER, LL_DEBUG, "OrcFileReader::getPosition(%ld) called.", pos); if (initJNIEnv() != JOI_OK) return OFR_ERROR_GETPOS_EXCEPTION; // long getPosition(); tsRecentJMFromJNI = JavaMethods_[JM_GETPOS].jm_full_name; Int64 result = jenv_->CallLongMethod(javaObj_, JavaMethods_[JM_GETPOS].methodID); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "OrcFileReader::getPosition()"); jenv_->PopLocalFrame(NULL); return OFR_ERROR_GETPOS_EXCEPTION; } if (result == -1) { logError(CAT_SQL_HDFS_ORC_FILE_READER, "OrcFileReader::getPosition()", getLastError()); jenv_->PopLocalFrame(NULL); return OFR_ERROR_GETPOS_EXCEPTION; } pos = result; jenv_->PopLocalFrame(NULL); return OFR_OK; }
HDFS_Client_RetCode HdfsClient::getFsDefaultName(char* buf, int buf_len) { QRLogger::log(CAT_SQL_HBASE, LL_DEBUG, "Enter HDFSClient_JNI::getFsDefaultName() called."); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_GET_FS_DEFAULT_NAME_PARAM; if (getInstance() == NULL) return HDFS_CLIENT_ERROR_GET_FS_DEFAULT_NAME_PARAM; tsRecentJMFromJNI = JavaMethods_[JM_GET_FS_DEFAULT_NAME].jm_full_name; jstring jresult = (jstring)jenv_->CallStaticObjectMethod(javaClass_, JavaMethods_[JM_GET_FS_DEFAULT_NAME].methodID); if (jenv_->ExceptionCheck()) { getExceptionDetails(jenv_); logError(CAT_SQL_HBASE, __FILE__, __LINE__); logError(CAT_SQL_HBASE, "HDFSClient_JNI::getFsDefaultName()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_GET_FS_DEFAULT_NAME_EXCEPTION; } const char* char_result = jenv_->GetStringUTFChars(jresult, 0); HDFS_Client_RetCode retcode = HDFS_CLIENT_OK; if ( buf_len >= strlen(char_result) ) { strcpy(buf, char_result); } else retcode = HDFS_CLIENT_ERROR_GET_FS_DEFAULT_NAME_BUFFER_TOO_SMALL; jenv_->ReleaseStringUTFChars(jresult, char_result); jenv_->PopLocalFrame(NULL); return retcode; }
HVC_RetCode HiveClient_JNI::getRedefTime(const char* schName, const char* tabName, Int64& redefTime) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Enter HiveClient_JNI::getRedefTime(%s, %s, %lld).", schName, tabName, redefTime); if (initJNIEnv() != JOI_OK) return HVC_ERROR_INIT_PARAM; if (getInstance() == NULL) return HVC_ERROR_INIT_PARAM; jstring js_schName = jenv_->NewStringUTF(schName); if (js_schName == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_GET_REDEFTIME_PARAM)); jenv_->PopLocalFrame(NULL); return HVC_ERROR_GET_REDEFTIME_PARAM; } jstring js_tabName = jenv_->NewStringUTF(tabName); if (js_tabName == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_GET_REDEFTIME_PARAM)); jenv_->PopLocalFrame(NULL); return HVC_ERROR_GET_REDEFTIME_PARAM; } // jlong getRedefTime(java.lang.String, java.lang.String); tsRecentJMFromJNI = JavaMethods_[JM_GET_RDT].jm_full_name; jlong jresult = jenv_->CallStaticLongMethod(javaClass_, JavaMethods_[JM_GET_RDT].methodID, js_schName, js_tabName); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::getRedefTime()"); jenv_->PopLocalFrame(NULL); return HVC_ERROR_GET_REDEFTIME_EXCEPTION; } QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Exit HiveClient_JNI::getRedefTime(%s, %s, %lld).", schName, tabName, redefTime); if (jresult <= 0) { jenv_->PopLocalFrame(NULL); return HVC_DONE; // Table does not exist } redefTime = jresult ; jenv_->PopLocalFrame(NULL); return HVC_OK; // Table exists. }
HDFS_Client_RetCode HdfsClient::hdfsMergeFiles( const NAString& srcPath, const NAString& dstPath) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsMergeFiles(%s, %s) called.", srcPath.data(), dstPath.data()); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM; if (getInstance() == NULL) return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM; jstring js_SrcPath = jenv_->NewStringUTF(srcPath.data()); if (js_SrcPath == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM; } jstring js_DstPath= jenv_->NewStringUTF(dstPath.data()); if (js_DstPath == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_PARAM; } tsRecentJMFromJNI = JavaMethods_[JM_HDFS_MERGE_FILES].jm_full_name; jboolean jresult = jenv_->CallStaticBooleanMethod(javaClass_, JavaMethods_[JM_HDFS_MERGE_FILES].methodID, js_SrcPath, js_DstPath); if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsClient::hdfsMergeFiles()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_EXCEPTION; } if (jresult == false) { logError(CAT_SQL_HDFS, "HdfsClient::hdfsMergeFiles()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_MERGE_FILES_EXCEPTION; } jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_OK; }
HDFS_Client_RetCode HdfsClient::hdfsCreate(const char* path, NABoolean overwrite, NABoolean compress) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsCreate(%s) called.", path); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_HDFS_CREATE_PARAM; setPath(path); jstring js_path = jenv_->NewStringUTF(path); if (js_path == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_CREATE_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_CREATE_PARAM; } jboolean j_compress = compress; jboolean j_overwrite = overwrite; if (hdfsStats_ != NULL) hdfsStats_->getHdfsTimer().start(); tsRecentJMFromJNI = JavaMethods_[JM_HDFS_CREATE].jm_full_name; jboolean jresult = jenv_->CallBooleanMethod(javaObj_, JavaMethods_[JM_HDFS_CREATE].methodID, js_path, j_overwrite, j_compress); if (hdfsStats_ != NULL) { hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop()); hdfsStats_->incHdfsCalls(); } if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsClient::hdfsCreate()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_CREATE_EXCEPTION; } if (jresult == false) { logError(CAT_SQL_HDFS, "HdfsClient::hdfsCreate()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_CREATE_PARAM; } jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_OK; }
Int32 HdfsClient::hdfsWrite(const char* data, Int64 len, HDFS_Client_RetCode &hdfsClientRetcode) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsWrite(%ld) called.", len); if (initJNIEnv() != JOI_OK) { hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_WRITE_EXCEPTION; return 0; } //Write the requisite bytes into the file jbyteArray jbArray = jenv_->NewByteArray( len); if (!jbArray) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_WRITE_PARAM)); jenv_->PopLocalFrame(NULL); hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_WRITE_PARAM; return 0; } jenv_->SetByteArrayRegion(jbArray, 0, len, (const jbyte*)data); if (hdfsStats_ != NULL) hdfsStats_->getHdfsTimer().start(); tsRecentJMFromJNI = JavaMethods_[JM_HDFS_WRITE].jm_full_name; // Java method returns the cumulative bytes written jint totalBytesWritten = jenv_->CallIntMethod(javaObj_, JavaMethods_[JM_HDFS_WRITE].methodID, jbArray); if (hdfsStats_ != NULL) { hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop()); hdfsStats_->incHdfsCalls(); } if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsClient::hdfsWrite()", getLastError()); jenv_->PopLocalFrame(NULL); hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_WRITE_EXCEPTION; return 0; } jenv_->PopLocalFrame(NULL); hdfsClientRetcode = HDFS_CLIENT_OK; Int32 bytesWritten = totalBytesWritten - totalBytesWritten_; totalBytesWritten_ = totalBytesWritten; return bytesWritten; }
OFR_RetCode OrcFileReader::getRowCount(Int64& count) { QRLogger::log(CAT_SQL_HDFS_ORC_FILE_READER, LL_DEBUG, "OrcFileReader::getRowCount() called."); if (initJNIEnv() != JOI_OK) return OFR_ERROR_GETNUMROWS_EXCEPTION; tsRecentJMFromJNI = JavaMethods_[JM_GETNUMROWS].jm_full_name; jlong jresult = (jlong)jenv_->CallObjectMethod(javaObj_, JavaMethods_[JM_GETNUMROWS].methodID); count = jresult; if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "OrcFileReader::getRowCount()"); jenv_->PopLocalFrame(NULL); return OFR_ERROR_GETNUMROWS_EXCEPTION; } jenv_->PopLocalFrame(NULL); return OFR_OK; }
HVC_RetCode HiveClient_JNI::exists(const char* schName, const char* tabName) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HiveClient_JNI::exists(%s, %s) called.", schName, tabName); if (initJNIEnv() != JOI_OK) return HVC_ERROR_INIT_PARAM; if (getInstance() == NULL) return HVC_ERROR_INIT_PARAM; jstring js_schName = jenv_->NewStringUTF(schName); if (js_schName == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_EXISTS_PARAM)); jenv_->PopLocalFrame(NULL); return HVC_ERROR_EXISTS_PARAM; } jstring js_tabName = jenv_->NewStringUTF(tabName); if (js_tabName == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_EXISTS_PARAM)); jenv_->PopLocalFrame(NULL); return HVC_ERROR_EXISTS_PARAM; } // boolean exists(java.lang.String, java.lang.String); tsRecentJMFromJNI = JavaMethods_[JM_EXISTS].jm_full_name; jboolean jresult = jenv_->CallStaticBooleanMethod(javaClass_, JavaMethods_[JM_EXISTS].methodID, js_schName, js_tabName); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::exists()"); jenv_->PopLocalFrame(NULL); return HVC_ERROR_EXISTS_EXCEPTION; } if (jresult == false) { jenv_->PopLocalFrame(NULL); return HVC_DONE; // Table does not exist } jenv_->PopLocalFrame(NULL); return HVC_OK; // Table exists. }
OFR_RetCode OrcFileReader::isEOF(bool& isEOF) { QRLogger::log(CAT_SQL_HDFS_ORC_FILE_READER, LL_DEBUG, "OrcFileReader::isEOF() called."); if (initJNIEnv() != JOI_OK) return OFR_ERROR_ISEOF_EXCEPTION; // boolean isEOF(); tsRecentJMFromJNI = JavaMethods_[JM_ISEOF].jm_full_name; bool result = jenv_->CallBooleanMethod(javaObj_, JavaMethods_[JM_ISEOF].methodID); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "OrcFileReader::isEOF()"); jenv_->PopLocalFrame(NULL); return OFR_ERROR_ISEOF_EXCEPTION; } isEOF = result; jenv_->PopLocalFrame(NULL); return OFR_OK; }
Int32 HdfsClient::hdfsRead(const char* data, Int64 len, HDFS_Client_RetCode &hdfsClientRetcode) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::hdfsWrite(%ld) called.", len); if (initJNIEnv() != JOI_OK) { hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_READ_EXCEPTION; return 0; } jobject j_buf = jenv_->NewDirectByteBuffer((BYTE *)data, len); if (j_buf == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HDFS_READ_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_READ_PARAM; } if (hdfsStats_ != NULL) hdfsStats_->getHdfsTimer().start(); tsRecentJMFromJNI = JavaMethods_[JM_HDFS_READ].jm_full_name; jint bytesRead = 0; bytesRead = jenv_->CallIntMethod(javaObj_, JavaMethods_[JM_HDFS_READ].methodID, j_buf); if (hdfsStats_ != NULL) { hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop()); hdfsStats_->incHdfsCalls(); } if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsClient::hdfsRead()", getLastError()); jenv_->PopLocalFrame(NULL); hdfsClientRetcode = HDFS_CLIENT_ERROR_HDFS_READ_EXCEPTION; return 0; } jenv_->PopLocalFrame(NULL); hdfsClientRetcode = HDFS_CLIENT_OK; return bytesRead; }
OFR_RetCode OrcFileReader::seeknSync(Int64 pos) { Int64 orcPos; if (initJNIEnv() != JOI_OK) return OFR_ERROR_SYNC_EXCEPTION; orcPos = pos -1; //When you position in ORC, reading the NEXT row will be one greater than what you wanted. QRLogger::log(CAT_SQL_HDFS_ORC_FILE_READER, LL_DEBUG, "OrcFileReader::seeknSync(%ld) called.", pos); // String seeknSync(long); tsRecentJMFromJNI = JavaMethods_[JM_SYNC].jm_full_name; jstring jresult = (jstring)jenv_->CallObjectMethod(javaObj_, JavaMethods_[JM_SYNC].methodID, orcPos); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "OrcFileReader::seeknSync()"); jenv_->PopLocalFrame(NULL); return OFR_ERROR_SYNC_EXCEPTION; } if (jresult != NULL) { const char *my_string = jenv_->GetStringUTFChars(jresult, JNI_FALSE); QRLogger::log(CAT_SQL_HDFS_ORC_FILE_READER, LL_DEBUG, "OrcFileReader::seeknSync(%ld) error: %s\n", pos, my_string); logError(CAT_SQL_HDFS_ORC_FILE_READER, "OrcFileReader::seeknSync()", jresult); jenv_->PopLocalFrame(NULL); return OFR_ERROR_SYNC_EXCEPTION; } jenv_->PopLocalFrame(NULL); return OFR_OK; }
HDFS_Client_RetCode HdfsClient::getHiveTableMaxModificationTs( Int64& maxModificationTs, const char * tableDirPaths, int levelDeep) { QRLogger::log(CAT_SQL_HBASE, LL_DEBUG, "Enter HDFSClient_JNI::getHiveTableMaxModificationTs(%s) called.",tableDirPaths); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_PARAM; if (getInstance() == NULL) return HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_PARAM; jstring js_tableDirPaths = jenv_->NewStringUTF(tableDirPaths); if (js_tableDirPaths == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_PARAM; } jint jlevelDeep = levelDeep; tsRecentJMFromJNI = JavaMethods_[JM_HIVE_TBL_MAX_MODIFICATION_TS].jm_full_name; jlong jresult = jenv_->CallStaticLongMethod(javaClass_, JavaMethods_[JM_HIVE_TBL_MAX_MODIFICATION_TS].methodID, js_tableDirPaths, jlevelDeep); jenv_->DeleteLocalRef(js_tableDirPaths); if (jenv_->ExceptionCheck()) { getExceptionDetails(jenv_); logError(CAT_SQL_HBASE, __FILE__, __LINE__); logError(CAT_SQL_HBASE, "HDFSClientI::getHiveTableMaxModificationTs()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HIVE_TBL_MAX_MODIFICATION_TS_EXCEPTION; } QRLogger::log(CAT_SQL_HBASE, LL_DEBUG, "Exit HDFSClient_JNI::getHiveTableMaxModificationTs() called."); maxModificationTs = jresult; jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_OK; }
HDFS_Client_RetCode HdfsClient::hdfsClose() { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsClient::close() called."); if (initJNIEnv() != JOI_OK) return HDFS_CLIENT_ERROR_HDFS_CLOSE_EXCEPTION; // String close(); if (hdfsStats_ != NULL) hdfsStats_->getHdfsTimer().start(); tsRecentJMFromJNI = JavaMethods_[JM_HDFS_CLOSE].jm_full_name; jboolean jresult = jenv_->CallBooleanMethod(javaObj_, JavaMethods_[JM_HDFS_CLOSE].methodID); if (hdfsStats_ != NULL) { hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop()); hdfsStats_->incHdfsCalls(); } if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsClient::hdfsClose()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_CLOSE_EXCEPTION; } if (jresult == false) { logError(CAT_SQL_HDFS, "HdfsClient::hdfsClose()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_ERROR_HDFS_CLOSE_EXCEPTION; } jenv_->PopLocalFrame(NULL); return HDFS_CLIENT_OK; }
JOI_RetCode JavaObjectInterface::init(char *className, jclass &javaClass, JavaMethodInit* JavaMethods, Int32 howManyMethods, bool methodsInitialized) { if (isInitialized_) return JOI_OK; JOI_RetCode retCode = JOI_OK; // Make sure the JVM environment is set up correctly. jclass lJavaClass; retCode = initJVM(); if (retCode != JOI_OK) return retCode; if (methodsInitialized == FALSE || javaObj_ == NULL) { if (javaClass == 0) { lJavaClass = jenv_->FindClass(className); if (jenv_->ExceptionCheck()) { getExceptionDetails(); QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_ERROR, "Exception in FindClass(%s).", className); return JOI_ERROR_FINDCLASS; } if (lJavaClass == 0) { QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_ERROR, "Error in FindClass(%s).", className); return JOI_ERROR_FINDCLASS; } javaClass = (jclass)jenv_->NewGlobalRef(lJavaClass); jenv_->DeleteLocalRef(lJavaClass); } // Initialize the method pointers. if (!methodsInitialized) { for (int i=0; i<howManyMethods; i++) { JavaMethods[i].jm_full_name = new (heap_) NAString(className, heap_); JavaMethods[i].jm_full_name->append('.', 1); JavaMethods[i].jm_full_name->append(JavaMethods[i].jm_name); JavaMethods[i].methodID = jenv_->GetMethodID(javaClass, JavaMethods[i].jm_name, JavaMethods[i].jm_signature); if (JavaMethods[i].methodID == 0 || jenv_->ExceptionCheck()) { getExceptionDetails(); QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_ERROR, "Error in GetMethod(%s).", JavaMethods[i].jm_name); return JOI_ERROR_GETMETHOD; } } } if (javaObj_ == NULL) { // Allocate an object of the Java class, and call its constructor. // The constructor must be the first entry in the methods array. jobject jObj = jenv_->NewObject(javaClass, JavaMethods[0].methodID); if (jObj == 0 || jenv_->ExceptionCheck()) { getExceptionDetails(); QRLogger::log(CAT_SQL_HDFS_JNI_TOP, LL_ERROR, "Error in NewObject() for class %s.", className); return JOI_ERROR_NEWOBJ; } javaObj_ = jenv_->NewGlobalRef(jObj); jenv_->DeleteLocalRef(jObj); } } isInitialized_ = true; return JOI_OK; }
////////////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////////////// //OFR_RetCode OrcFileReader::fetchNextRow(Int64 stopOffset, char* buffer) OFR_RetCode OrcFileReader::fetchNextRow(char * buffer, long& array_length, long& rowNumber, int& num_columns) { if (initJNIEnv() != JOI_OK) return OFR_ERROR_FETCHROW_EXCEPTION; /* // java.lang.String fetchNextRow(long stopOffset); jstring jresult = (jstring)jenv_->CallObjectMethod(javaObj_, JavaMethods_[JM_FETCHROW2].methodID, stopOffset); if (jresult==NULL && getLastError()) { logError(CAT_SQL_HDFS_ORC_FILE_READER, "OrcFileReader::fetchNextRow()", getLastError()); jenv_->PopLocalFrame(NULL); return OFR_ERROR_FETCHROW_EXCEPTION; } if (jresult == NULL) { return OFR_NOMORE; } const char* char_result = jenv_->GetStringUTFChars(jresult, 0); strcpy(buffer, char_result); jenv_->ReleaseStringUTFChars(jresult, char_result); jenv_->PopLocalFrame(NULL); return OFR_OK; */ jfieldID fid; tsRecentJMFromJNI = JavaMethods_[JM_FETCHROW2].jm_full_name; jobject jresult = (jobject)jenv_->CallObjectMethod(javaObj_, JavaMethods_[JM_FETCHROW2].methodID); if (jenv_->ExceptionCheck()) { getExceptionDetails(__FILE__, __LINE__, "OrcFileReader::fetchNextRow()"); jenv_->PopLocalFrame(NULL); return OFR_ERROR_FETCHROW_EXCEPTION; } if (jresult==NULL && getLastError()) { logError(CAT_SQL_HDFS_ORC_FILE_READER, "OrcFileReader::fetchNextRow()", getLastError()); return OFR_ERROR_FETCHROW_EXCEPTION; } if (jresult == NULL) return (OFR_NOMORE); //No more rows //Retrieve row and associated data jclass cls = jenv_->GetObjectClass(jresult); fid = jenv_->GetFieldID(cls,"m_row_length","I"); if (fid ==NULL) { jenv_->PopLocalFrame(NULL); return (OFR_ERROR_FETCHROW_EXCEPTION); } jint row_length = (jint)jenv_->GetIntField(jresult, fid); array_length = (long)row_length; fid = jenv_->GetFieldID(cls,"m_column_count","I"); if (fid ==NULL) { jenv_->PopLocalFrame(NULL); return(OFR_ERROR_FETCHROW_EXCEPTION); } jint column_count = (jint)jenv_->GetIntField(jresult, fid); num_columns = column_count; fid = jenv_->GetFieldID(cls,"m_row_number","J"); if (fid ==NULL) { jenv_->PopLocalFrame(NULL); return(OFR_ERROR_FETCHROW_EXCEPTION); } jlong rowNum = (jlong)jenv_->GetIntField(jresult, fid); rowNumber = rowNum; // Get the actual row (it is a byte array). Use the row_length above to specify how much to copy fid = jenv_->GetFieldID(cls,"m_row_ba","[B"); if (fid ==NULL) { jenv_->PopLocalFrame(NULL); return (OFR_ERROR_FETCHROW_EXCEPTION); } jbyteArray jrow = (jbyteArray)jenv_->GetObjectField(jresult, fid); if (jrow == NULL) { jenv_->PopLocalFrame(NULL); return (OFR_ERROR_FETCHROW_EXCEPTION); } jenv_->GetByteArrayRegion(jrow, 0, row_length, (jbyte*)buffer); jenv_->PopLocalFrame(NULL); return (OFR_OK); }
HDFS_Scan_RetCode HdfsScan::setScanRanges(ExHdfsScanTcb::HDFS_SCAN_BUF *hdfsScanBuf, int scanBufSize, HdfsFileInfoArray *hdfsFileInfoArray, Int32 beginRangeNum, Int32 numRanges, int rangeTailIOSize) { QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HdfsScan::setScanRanges() called."); if (initJNIEnv() != JOI_OK) return HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM; jobject j_buf1 = jenv_->NewDirectByteBuffer(hdfsScanBuf[0].buf_, scanBufSize); if (j_buf1 == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM; } j_buf1_ = jenv_->NewGlobalRef(j_buf1); if (j_buf1_ == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM; } jobject j_buf2 = jenv_->NewDirectByteBuffer(hdfsScanBuf[1].buf_, scanBufSize); if (j_buf2 == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM; } j_buf2_ = jenv_->NewGlobalRef(j_buf2); if (j_buf2_ == NULL) { GetCliGlobals()->setJniErrorStr(getErrorText(HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM)); jenv_->PopLocalFrame(NULL); return HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM; } jobjectArray j_filenames = NULL; jlongArray j_offsets = NULL; jlongArray j_lens = NULL; jintArray j_rangenums = NULL; HdfsFileInfo *hdfo; jstring j_obj; HDFS_Scan_RetCode hdfsScanRetCode = HDFS_SCAN_ERROR_SET_SCAN_RANGES_PARAM; int arrayLen = hdfsFileInfoArray->entries(); for (Int32 i = beginRangeNum, rangeCount=0; i < arrayLen; i++, rangeCount++) { if (rangeCount >= numRanges) break; hdfo = hdfsFileInfoArray->at(i); j_obj = jenv_->NewStringUTF(hdfo->fileName()); if (jenv_->ExceptionCheck()) { jenv_->PopLocalFrame(NULL); return hdfsScanRetCode; } if (j_filenames == NULL) { j_filenames = jenv_->NewObjectArray(numRanges, jenv_->GetObjectClass(j_obj), NULL); if (jenv_->ExceptionCheck()) { jenv_->PopLocalFrame(NULL); return hdfsScanRetCode; } } jenv_->SetObjectArrayElement(j_filenames, rangeCount, (jobject)j_obj); jenv_->DeleteLocalRef(j_obj); if (j_offsets == NULL) { j_offsets = jenv_->NewLongArray(numRanges); if (jenv_->ExceptionCheck()) { jenv_->PopLocalFrame(NULL); return hdfsScanRetCode; } } long offset = hdfo->getStartOffset(); jenv_->SetLongArrayRegion(j_offsets, rangeCount, 1, &offset); if (j_lens == NULL) { j_lens = jenv_->NewLongArray(numRanges); if (jenv_->ExceptionCheck()) { jenv_->PopLocalFrame(NULL); return hdfsScanRetCode; } } long len = hdfo->getBytesToRead()+rangeTailIOSize; jenv_->SetLongArrayRegion(j_lens, rangeCount, 1, &len); if (j_rangenums == NULL) { j_rangenums = jenv_->NewIntArray(numRanges); if (jenv_->ExceptionCheck()) { jenv_->PopLocalFrame(NULL); return hdfsScanRetCode; } } jint tdbRangeNum = i; jenv_->SetIntArrayRegion(j_rangenums, rangeCount, 1, &tdbRangeNum); } if (hdfsStats_ != NULL) hdfsStats_->getHdfsTimer().start(); tsRecentJMFromJNI = JavaMethods_[JM_SET_SCAN_RANGES].jm_full_name; jenv_->CallVoidMethod(javaObj_, JavaMethods_[JM_SET_SCAN_RANGES].methodID, j_buf1, j_buf2, j_filenames, j_offsets, j_lens, j_rangenums); if (hdfsStats_ != NULL) { hdfsStats_->incMaxHdfsIOTime(hdfsStats_->getHdfsTimer().stop()); hdfsStats_->incHdfsCalls(); } if (jenv_->ExceptionCheck()) { getExceptionDetails(); logError(CAT_SQL_HDFS, __FILE__, __LINE__); logError(CAT_SQL_HDFS, "HdfsScan::setScanRanges()", getLastError()); jenv_->PopLocalFrame(NULL); return HDFS_SCAN_ERROR_SET_SCAN_RANGES_EXCEPTION; } return HDFS_SCAN_OK; }