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;
}
