// **********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
// **********************************************************************

#include "QRLogger.h"
#include "Globals.h"
#include "Context.h"
#include "jni.h"
#include "HiveClient_JNI.h"
#include "org_trafodion_sql_HiveClient.h"

// ===========================================================================
// ===== Class HiveClient_JNI
// ===========================================================================

JavaMethodInit* HiveClient_JNI::JavaMethods_ = NULL;
jclass HiveClient_JNI::javaClass_ = 0;
bool HiveClient_JNI::javaMethodsInitialized_ = false;
pthread_mutex_t HiveClient_JNI::javaMethodsInitMutex_ = PTHREAD_MUTEX_INITIALIZER;

static const char* const hvcErrorEnumStr[] = 
{
  "Preparing parameters for HiveClient."
 ,"Java exception in init()."
 ,"Java exception in close()."
 ,"Preparing parameters for exists()."
 ,"Java exception in exists()."
 ,"Preparing parameters for getRedefTime()."
 ,"Java exception in getRedefTime()."
 ,"Java exception in getAllSchemas()."
 ,"Preparing parameters for getAllTables()."
 ,"Java exception in getAllTables()."
 ,"Preparing parameters for executeHiveSQL()."
 ,"Java exception in executeHiveSQL()."
 ,"Preparing parameters for getHiveTableInfo()."
 ,"Java exception in getHiveTableInfo()."
 ,"Error in getHiveTableInfoDetails()."
 ,"Error during populdate SDs."
};


//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////
char* HiveClient_JNI::getErrorText(HVC_RetCode errEnum)
{
  if (errEnum < (HVC_RetCode)JOI_LAST)
    return JavaObjectInterface::getErrorText((JOI_RetCode)errEnum);
  else    
    return (char*)hvcErrorEnumStr[errEnum-HVC_FIRST-1];
}

//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////
HiveClient_JNI* HiveClient_JNI::newInstance(NAHeap *heap, HVC_RetCode &retCode)
{
   QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HiveClient_JNI::newInstance() called.");

   if (initJNIEnv() != JOI_OK)
     return NULL;
   retCode = HVC_OK;
   HiveClient_JNI *hiveClient_JNI = new (heap) HiveClient_JNI(heap);
   if (hiveClient_JNI != NULL) {
       retCode = hiveClient_JNI->initConnection();
       if (retCode != HVC_OK) {
          NADELETE(hiveClient_JNI, HiveClient_JNI, heap);
          hiveClient_JNI = NULL;
       }
   }
   return hiveClient_JNI;
}

//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////
HiveClient_JNI* HiveClient_JNI::getInstance()
{
   HVC_RetCode hvcRetcode = HVC_OK;

   ContextCli *currContext = GetCliGlobals()->currContext();
   HiveClient_JNI *hiveClient_JNI = currContext->getHiveClient();
   if (hiveClient_JNI == NULL)
   { 
       NAHeap *heap = currContext->exHeap();
       hiveClient_JNI = new (heap) HiveClient_JNI(heap);
       if ((hvcRetcode = hiveClient_JNI->init()) == HVC_OK)
          currContext->setHiveClient(hiveClient_JNI);
       else {
          NADELETE(hiveClient_JNI, HiveClient_JNI, heap);
          hiveClient_JNI = NULL;
       }
   }
   return hiveClient_JNI;
}

void HiveClient_JNI::deleteInstance()
{
  ContextCli *currContext = GetCliGlobals()->currContext();
  HiveClient_JNI *hiveClient_JNI = currContext->getHiveClient();
  if (hiveClient_JNI != NULL)
  {
     NAHeap *heap = currContext->exHeap();
     NADELETE(hiveClient_JNI, HiveClient_JNI, heap);
     currContext->setHiveClient(NULL);
  }
}

//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////
HiveClient_JNI::~HiveClient_JNI()
{
   cleanupTableInfo();
   if (isConnected_)	
      close(); // error handling
}

//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////
HVC_RetCode HiveClient_JNI::init()
{
  static char className[]="org/trafodion/sql/HiveClient";
  HVC_RetCode rc;

  if (isInitialized())
    return HVC_OK;
  
  if (javaMethodsInitialized_)
    return (HVC_RetCode)JavaObjectInterface::init(className, javaClass_, JavaMethods_, (Int32)JM_LAST, javaMethodsInitialized_);
  else
  {
    pthread_mutex_lock(&javaMethodsInitMutex_);
    if (javaMethodsInitialized_)
    {
      pthread_mutex_unlock(&javaMethodsInitMutex_);
      return (HVC_RetCode)JavaObjectInterface::init(className, javaClass_, JavaMethods_, (Int32)JM_LAST, javaMethodsInitialized_);
    }
    JavaMethods_ = new JavaMethodInit[JM_LAST];
    
    JavaMethods_[JM_CTOR       ].jm_name      = "<init>";
    JavaMethods_[JM_CTOR       ].jm_signature = "()V";
    JavaMethods_[JM_INIT       ].jm_name      = "init";
    JavaMethods_[JM_INIT       ].jm_signature = "()Z";
    JavaMethods_[JM_CLOSE      ].jm_name      = "close";	
    JavaMethods_[JM_CLOSE      ].jm_signature = "()Z";
    JavaMethods_[JM_EXISTS     ].jm_name      = "exists";
    JavaMethods_[JM_EXISTS     ].jm_signature = "(Ljava/lang/String;Ljava/lang/String;)Z";
    JavaMethods_[JM_GET_RDT    ].jm_name      = "getRedefTime";
    JavaMethods_[JM_GET_RDT    ].jm_signature = "(Ljava/lang/String;Ljava/lang/String;)J";
    JavaMethods_[JM_GET_ASH     ].jm_name      = "getAllSchemas";
    JavaMethods_[JM_GET_ASH     ].jm_signature = "()[Ljava/lang/Object;";
    JavaMethods_[JM_GET_ATL    ].jm_name      = "getAllTables";
    JavaMethods_[JM_GET_ATL    ].jm_signature = "(Ljava/lang/String;)[Ljava/lang/Object;";
    JavaMethods_[JM_EXEC_HIVE_SQL].jm_name = "executeHiveSQL";
    JavaMethods_[JM_EXEC_HIVE_SQL].jm_signature = "(Ljava/lang/String;)V";
    JavaMethods_[JM_GET_HVT_INFO].jm_name      = "getHiveTableInfo";
    JavaMethods_[JM_GET_HVT_INFO].jm_signature = "(JLjava/lang/String;Ljava/lang/String;Z)Z";

    rc = (HVC_RetCode)JavaObjectInterface::init(className, javaClass_, JavaMethods_, (Int32)JM_LAST, javaMethodsInitialized_);
    if (rc == HVC_OK)
       javaMethodsInitialized_ = TRUE;
    pthread_mutex_unlock(&javaMethodsInitMutex_);
  }
  return rc;
}

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


//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////
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.
}

//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////  
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.
}

//////////////////////////////////////////////////////////////////////////////
// 
////////////////////////////////////////////////////////////////////////////// 
HVC_RetCode HiveClient_JNI::getAllSchemas(NAHeap *heap, LIST(Text *)& schNames)
{
  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Enter HiveClient_JNI::getAllSchemas(%p) called.", (void *) &schNames);
  if (initJNIEnv() != JOI_OK)
     return HVC_ERROR_INIT_PARAM;
  if (getInstance() == NULL)
     return HVC_ERROR_INIT_PARAM;

  tsRecentJMFromJNI = JavaMethods_[JM_GET_ASH].jm_full_name;
  jarray j_schNames= 
     (jarray)jenv_->CallStaticObjectMethod(javaClass_, JavaMethods_[JM_GET_ASH].methodID);

  if (jenv_->ExceptionCheck())
  {
    getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::getAllSchemas()");
    jenv_->PopLocalFrame(NULL);
    return HVC_ERROR_GET_ALLSCH_EXCEPTION;
  }

  int numSchemas = convertStringObjectArrayToList(heap, j_schNames,
                   schNames);           
  if (numSchemas == 0) {
     jenv_->PopLocalFrame(NULL);
     return HVC_DONE;
  }
  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, 
       "Exit HiveClient_JNI::getAllSchemas(%p) called.", (void *) &schNames);
  jenv_->PopLocalFrame(NULL);
  return HVC_OK;
}

//////////////////////////////////////////////////////////////////////////////
// 
////////////////////////////////////////////////////////////////////////////// 
HVC_RetCode HiveClient_JNI::executeHiveSQL(const char* hiveSQL)
{
  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Enter HiveClient_JNI::executeHiveSQL(%s) called.", hiveSQL);
  if (initJNIEnv() != JOI_OK)
     return HVC_ERROR_INIT_PARAM;
  if (getInstance() == NULL)
     return HVC_ERROR_INIT_PARAM;

  jstring js_hiveSQL = jenv_->NewStringUTF(hiveSQL);
  if (js_hiveSQL == NULL) 
  {
    GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_GET_ALLTBL_PARAM));
    jenv_->PopLocalFrame(NULL);
    return HVC_ERROR_EXECUTE_HIVE_SQL_PARAM;
  }
  
  tsRecentJMFromJNI = JavaMethods_[JM_EXEC_HIVE_SQL].jm_full_name;
  jenv_->CallStaticVoidMethod(javaClass_, JavaMethods_[JM_EXEC_HIVE_SQL].methodID, js_hiveSQL);

  if (jenv_->ExceptionCheck())
  {
    getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::executeHiveSQL()",
                        TRUE /*dont return stack details*/);
    jenv_->PopLocalFrame(NULL);
    return HVC_ERROR_EXECUTE_HIVE_SQL_EXCEPTION;
  }

  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, 
       "Exit HiveClient_JNI::executeHiveSQL(%s) called.", hiveSQL);
  jenv_->PopLocalFrame(NULL);
  return HVC_OK;
}

//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////
HVC_RetCode HiveClient_JNI::getAllTables(NAHeap *heap, const char* schName, 
                                         LIST(Text *)& tblNames)
{
  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Enter HiveClient_JNI::getAllTables(%s, %p) called.", schName, (void *) &tblNames);
  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_ALLTBL_PARAM));
    jenv_->PopLocalFrame(NULL);
    return HVC_ERROR_GET_ALLTBL_PARAM;
  }

  tsRecentJMFromJNI = JavaMethods_[JM_GET_ATL].jm_full_name;
  jarray j_tblNames = 
    (jarray)jenv_->CallStaticObjectMethod(javaClass_, JavaMethods_[JM_GET_ATL].methodID, 
                            js_schName);

  if (jenv_->ExceptionCheck())
  {
    getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::getAllTables()");
    jenv_->PopLocalFrame(NULL);
    return HVC_ERROR_GET_ALLTBL_EXCEPTION;
  }

  if (j_tblNames == NULL) 	
  {	
     GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_EXISTS_EXCEPTION));
     jenv_->PopLocalFrame(NULL);	
     return HVC_ERROR_EXISTS_EXCEPTION;	
  }

  int numTables = convertStringObjectArrayToList(heap, j_tblNames,
                   tblNames);           
  if (numTables == 0) {
     jenv_->PopLocalFrame(NULL);
     return HVC_DONE;
  }
  jenv_->PopLocalFrame(NULL);
  return HVC_OK;
}

//////////////////////////////////////////////////////////////////////////////	
// 	
//////////////////////////////////////////////////////////////////////////////	
HVC_RetCode HiveClient_JNI::close()	
{	
  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "HiveClient_JNI::close() called.");	
	
  if (initJNIEnv() != JOI_OK)	
     return HVC_ERROR_INIT_PARAM;	
	
  // boolean close();	
  tsRecentJMFromJNI = JavaMethods_[JM_CLOSE].jm_full_name;	
  jboolean jresult = jenv_->CallStaticBooleanMethod(javaClass_, JavaMethods_[JM_CLOSE].methodID);	
  if (jenv_->ExceptionCheck())	
  {	
    getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::close()");	
    jenv_->PopLocalFrame(NULL);	
    return HVC_ERROR_CLOSE_EXCEPTION;	
  }	
  	
  if (jresult == false) 	
  {	
    logError(CAT_SQL_HDFS, "HiveClient_JNI::close()", getLastError());	
    jenv_->PopLocalFrame(NULL);	
    return HVC_ERROR_CLOSE_EXCEPTION;	
  }	
	
  jenv_->PopLocalFrame(NULL);	
  return HVC_OK;	
}

//////////////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////////////  
//
//////////////////////////////////////////////////////////////////////////////
HVC_RetCode HiveClient_JNI::getHiveTableInfo(const char* schName, 
                                            const char* tabName,
                                            NABoolean readPartnInfo)
{
  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Enter HiveClient_JNI::getHiveTableInfo(%s, %s)", schName, tabName);
  if (initJNIEnv() != JOI_OK)
     return HVC_ERROR_INIT_PARAM;
  jstring js_schName = jenv_->NewStringUTF(schName);
  if (js_schName == NULL) 
  {
    GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_GET_HVT_INFO_PARAM));
    jenv_->PopLocalFrame(NULL);
    return HVC_ERROR_GET_HVT_INFO_PARAM;
  }
  jstring js_tabName = jenv_->NewStringUTF(tabName);
  if (js_tabName == NULL) 
  {
    GetCliGlobals()->setJniErrorStr(getErrorText(HVC_ERROR_GET_HVT_INFO_PARAM));
    jenv_->PopLocalFrame(NULL);
    return HVC_ERROR_GET_HVT_INFO_PARAM;
  }
  jboolean jReadPartn = readPartnInfo;
  jlong jniObject = (jlong)this;
  tsRecentJMFromJNI = JavaMethods_[JM_GET_HVT_INFO].jm_full_name;
  jboolean jresult = jenv_->CallBooleanMethod(javaObj_, 
                                            JavaMethods_[JM_GET_HVT_INFO].methodID, 
                                            jniObject,
                                            js_schName, js_tabName, jReadPartn);
  if (jenv_->ExceptionCheck())
  {
    getExceptionDetails(__FILE__, __LINE__, "HiveClient_JNI::getHiveTableStr()");
    jenv_->PopLocalFrame(NULL);
    return HVC_ERROR_GET_HVT_INFO_EXCEPTION;
  }
  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, "Exit HiveClient_JNI::getHiveTableInfo(%s, %s).", schName, tabName);
  jenv_->PopLocalFrame(NULL);
  if (jresult)
     return HVC_OK;
  else
     return HVC_DONE;
}

#ifdef __cplusplus
extern "C" {
#endif

/*
 * Class:     org_trafodion_sql_HiveClient
 * Method:    setTableInfo
 * Signature: (J[Ljava/lang/String;[[Ljava/lang/String;[[Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;[I[Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;[[Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_org_trafodion_sql_HiveClient_setTableInfo
  (JNIEnv *jniEnv, jobject jobj, jlong jniObject, jobjectArray tableInfo, jobjectArray colInfo, jobjectArray partKeyInfo, 
                jobjectArray bucketCols, jobjectArray sortCols, jintArray sortColsOrder, jobjectArray paramsKeys, jobjectArray paramsValues,
                jobjectArray partNames, jobjectArray partKeyValues)
{
   HiveClient_JNI *hiveClient = (HiveClient_JNI *)jniObject; 
   hiveClient->setTableInfo(tableInfo, colInfo, partKeyInfo, bucketCols, sortCols, sortColsOrder, paramsKeys, paramsValues, 
                                partNames, partKeyValues);
}
#ifdef __cplusplus
}
#endif

void HiveClient_JNI::setTableInfo(jobjectArray tableInfo, jobjectArray colInfo, jobjectArray partKeyInfo, 
                jobjectArray bucketCols, jobjectArray sortCols, jintArray sortColsOrder,jobjectArray paramsKeys, jobjectArray paramsValues,
                jobjectArray partNames, jobjectArray partKeyValues)
{
   NABoolean exceptionFound = FALSE;
   tableInfo_ = (jobjectArray)jenv_->NewGlobalRef(tableInfo);
   if (jenv_->ExceptionCheck())
      exceptionFound = TRUE; 
   if (! exceptionFound) {
      colInfo_ = (jobjectArray)jenv_->NewGlobalRef(colInfo);
      if (jenv_->ExceptionCheck())
          exceptionFound = TRUE; 
   }
   if (! exceptionFound) {
      if (partKeyInfo != NULL) {
         partKeyInfo_ = (jobjectArray)jenv_->NewGlobalRef(partKeyInfo);
         if (jenv_->ExceptionCheck())
             exceptionFound = TRUE; 
      }
   }
   if (! exceptionFound) {
      if (bucketCols != NULL) {
         bucketCols_ = (jobjectArray)jenv_->NewGlobalRef(bucketCols);
         if (jenv_->ExceptionCheck())
             exceptionFound = TRUE; 
      }
   }
   if (! exceptionFound) {
      if (sortCols != NULL) {
         sortCols_ = (jobjectArray)jenv_->NewGlobalRef(sortCols);
         if (jenv_->ExceptionCheck())
             exceptionFound = TRUE; 
      }
   }
   if (! exceptionFound) {
      if (sortColsOrder != NULL) {
         sortColsOrder_ = (jintArray)jenv_->NewGlobalRef(sortColsOrder);
         if (jenv_->ExceptionCheck())
             exceptionFound = TRUE; 
      }
   }
   if (! exceptionFound) {
      if (paramsKeys != NULL) {
         paramsKeys_ = (jobjectArray)jenv_->NewGlobalRef(paramsKeys);
         if (jenv_->ExceptionCheck())
             exceptionFound = TRUE; 
      }
   }
   if (! exceptionFound) {
      if (paramsValues != NULL) {
         paramsValues_ = (jobjectArray)jenv_->NewGlobalRef(paramsValues);
         if (jenv_->ExceptionCheck())
             exceptionFound = TRUE; 
      }
   }
   if (! exceptionFound) {
      if (partNames != NULL) {
         partNames_ = (jobjectArray)jenv_->NewGlobalRef(partNames);
         if (jenv_->ExceptionCheck())
             exceptionFound = TRUE; 
      }
   }
   if (! exceptionFound) {
      if (partKeyValues != NULL) {
         partKeyValues_ = (jobjectArray)jenv_->NewGlobalRef(partKeyValues);
         if (jenv_->ExceptionCheck())
             exceptionFound = TRUE; 
      }
   }
   ex_assert(! exceptionFound, "Exception in HiveClient_JNI::setTableInfo");
}

void HiveClient_JNI::cleanupTableInfo() 
{
   if (tableInfo_ != NULL) {
      jenv_->DeleteGlobalRef(tableInfo_);
      tableInfo_ = NULL;
   }
   if (colInfo_ != NULL) {
      jenv_->DeleteGlobalRef(colInfo_);
      colInfo_ = NULL;
   }
   if (partKeyInfo_ != NULL) {
      jenv_->DeleteGlobalRef(partKeyInfo_);
      partKeyInfo_ = NULL;
   }
   if (bucketCols_ != NULL) {
      jenv_->DeleteGlobalRef(bucketCols_);
      bucketCols_ = NULL;
   }
   if (sortCols_ != NULL) {
      jenv_->DeleteGlobalRef(sortCols_);
      sortCols_ = NULL;
   }
   if (sortColsOrder_ != NULL) {
      jenv_->DeleteGlobalRef(sortColsOrder_);
      sortColsOrder_ = NULL;
   }
   if (paramsKeys_ != NULL) {
      jenv_->DeleteGlobalRef(paramsKeys_);
      paramsKeys_ = NULL;
   }
   if (paramsValues_ != NULL) {
      jenv_->DeleteGlobalRef(paramsValues_);
      paramsValues_ = NULL;
   }
   if (partNames_ != NULL) {
      jenv_->DeleteGlobalRef(partNames_);
      partNames_ = NULL;
   }
   if (partKeyValues_ != NULL) {
      jenv_->DeleteGlobalRef(partKeyValues_);
      partKeyValues_ = NULL;
   }
}

HVC_RetCode HiveClient_JNI::getHiveTableDesc(NAHeap *heap, hive_tbl_desc *&hiveTableDesc)
{
   HVC_RetCode hvcRetcode;
   jstring jTableInfo[7];
   const char *pTableInfo[7];
   Int64 creationTs;

   jTableInfo[0] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_TABLE_NAME);
   pTableInfo[0] = jenv_->GetStringUTFChars(jTableInfo[0], NULL);

   jTableInfo[1] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_DB_NAME);
   pTableInfo[1] = jenv_->GetStringUTFChars(jTableInfo[1], NULL);

   jTableInfo[2] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_OWNER);
   pTableInfo[2] = jenv_->GetStringUTFChars(jTableInfo[2], NULL);

   jTableInfo[3] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_TABLE_TYPE);
   pTableInfo[3] = jenv_->GetStringUTFChars(jTableInfo[3], NULL);

   jTableInfo[4] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_VIEW_ORIGINAL_TEXT);
   if (jTableInfo[4] != NULL)
      pTableInfo[4] = jenv_->GetStringUTFChars(jTableInfo[4], NULL);
   else
      pTableInfo[4] = NULL;
    
   jTableInfo[5] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_VIEW_EXPANDED_TEXT);
   if (jTableInfo[5] != NULL)
       pTableInfo[5] = jenv_->GetStringUTFChars(jTableInfo[5], NULL);
   else
      pTableInfo[5] = NULL;

   jTableInfo[6] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_CREATE_TIME);
   pTableInfo[6] = jenv_->GetStringUTFChars(jTableInfo[6], NULL);
   creationTs = atol(pTableInfo[6]);
   hive_sd_desc *hiveSdDesc;
   if ((hvcRetcode = populateSD(heap, creationTs, hiveSdDesc)) != HVC_OK)
      return hvcRetcode;

   struct hive_pkey_desc* partKeyDesc; 
   if ((hvcRetcode = populatePartKeyColumns(heap, partKeyDesc)) != HVC_OK)
       return hvcRetcode;
   
   struct hive_tblparams_desc *tblParamsDesc;
   if ((hvcRetcode = populateTableParams(heap, hiveSdDesc, tblParamsDesc)) != HVC_OK)
       return hvcRetcode;

   hiveTableDesc =  new (heap)
      struct hive_tbl_desc(heap, 0, // no tblID with JNI 
                          pTableInfo[0], // Table Name
                          pTableInfo[1], // schema Name
                          pTableInfo[2], // owner
                          pTableInfo[3], // table type
                          creationTs,
                          pTableInfo[4], // view original str
                          pTableInfo[5], // view expanded  str
                          hiveSdDesc, partKeyDesc, tblParamsDesc); 

   for (int i = 0; i < 7 ; i++) {
      if (jTableInfo[i] != NULL) {
         jenv_->ReleaseStringUTFChars(jTableInfo[i], pTableInfo[i]);
         jenv_->DeleteLocalRef(jTableInfo[i]);
      }
   }
   return HVC_OK; 
} 

HVC_RetCode HiveClient_JNI::populateSD(NAHeap *heap, Int64 creationTs, hive_sd_desc* &sdDesc)
{
   HVC_RetCode hvcRetcode;

   if (tableInfo_ == NULL)
      return HVC_ERROR_POPULATE_SDS_ERROR;

   struct hive_sd_desc* lastSd = NULL;
   char fieldTerminator  = '\001';  // this the Hive default ^A or ascii code 1
   char recordTerminator = '\n';    // this is the Hive default


   jstring jSdEntries[8]; 
   const char *pSdEntries[8];

   NABoolean isCompressed = FALSE;
   Int32 numBuckets = 0;

   jSdEntries[0] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_SD_LOCATION);
   if (jSdEntries[0] != NULL)
      pSdEntries[0] = jenv_->GetStringUTFChars(jSdEntries[0], NULL);
   else
      pSdEntries[0] = NULL;

   jSdEntries[1] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_SD_INPUT_FORMAT);
   pSdEntries[1] = jenv_->GetStringUTFChars(jSdEntries[1], NULL);

   jSdEntries[2] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_SD_OUTPUT_FORMAT);
   pSdEntries[2] = jenv_->GetStringUTFChars(jSdEntries[2], NULL);

   jSdEntries[3] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_SD_COMPRESSED);
   pSdEntries[3] = jenv_->GetStringUTFChars(jSdEntries[3], NULL);
   if (strcmp(pSdEntries[3], "true") == 0)
      isCompressed = TRUE;

   jSdEntries[4] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_SD_NUM_BUCKETS);
   pSdEntries[4] = jenv_->GetStringUTFChars(jSdEntries[4], NULL);
   numBuckets = atoi(pSdEntries[4]); 

   jSdEntries[5] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_NULL_FORMAT);
   if (jSdEntries[5] != NULL) 
      pSdEntries[5] = jenv_->GetStringUTFChars(jSdEntries[5], NULL);
   else
      pSdEntries[5] = NULL;
   
   jSdEntries[6] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_FIELD_DELIM);
   if (jSdEntries[6] != NULL)  {
      pSdEntries[6] = jenv_->GetStringUTFChars(jSdEntries[6], NULL);
      fieldTerminator = *pSdEntries[6];
   }
   else
      pSdEntries[6] = NULL;

   jSdEntries[7] = (jstring)jenv_->GetObjectArrayElement(tableInfo_, org_trafodion_sql_HiveClient_Table_LINE_DELIM);
   if (jSdEntries[7] != NULL) {
      pSdEntries[7] = jenv_->GetStringUTFChars(jSdEntries[7], NULL);
      recordTerminator = *pSdEntries[7];
   }
   else
      pSdEntries[7] = NULL;
  
   struct hive_column_desc* colsDesc; 
   if ((hvcRetcode = populateColumns(heap, colsDesc)) != HVC_OK)
       return hvcRetcode;

   struct hive_skey_desc *sortColsDesc;
   if ((hvcRetcode = populateSortColumns(heap, sortColsDesc)) != HVC_OK)
       return hvcRetcode;

   struct hive_bkey_desc *bucketColsDesc;
   if ((hvcRetcode = populateBucketColumns(heap, bucketColsDesc)) != HVC_OK)
       return hvcRetcode;

   jint numPartns = 0;
    
   struct hive_sd_desc* tableSdDesc = new (heap)
        struct hive_sd_desc(heap, 0, //SdID
                            pSdEntries[0], // Location
                            creationTs,
                            numBuckets, // numBuckets
                            pSdEntries[1], // input format
                            pSdEntries[2], // output format
                            pSdEntries[5],  // null format
                            hive_sd_desc::TABLE_SD,
                            colsDesc,
                            sortColsDesc,
                            bucketColsDesc,
                            fieldTerminator,
                            recordTerminator,
                            isCompressed,
                            NULL);
   lastSd = tableSdDesc;
   jobjectArray partValuesArray;
   if (partKeyValues_ != NULL) {
      numPartns = jenv_->GetArrayLength(partKeyValues_);     
      for (int partNum = 0 ; partNum < numPartns ; partNum++) {
          jstring jPartName = (jstring)jenv_->GetObjectArrayElement(partNames_, partNum);
          const char *pPartName = jenv_->GetStringUTFChars(jPartName, NULL);
          jobjectArray jPartKeyValues = (jobjectArray)jenv_->GetObjectArrayElement(partKeyValues_, partNum);
          int numPartKeyValues = jenv_->GetArrayLength(jPartKeyValues);       
          NAString partKeyValue(heap);
          for (int partKeyValueIdx = 0 ; partKeyValueIdx < numPartKeyValues; partKeyValueIdx++) {
             jstring jPartKeyValue = (jstring)jenv_->GetObjectArrayElement(jPartKeyValues, partKeyValueIdx);
             const char *pPartKeyValue = jenv_->GetStringUTFChars(jPartKeyValue, NULL);
             if (partKeyValueIdx != 0)
                partKeyValue += ", ";
             partKeyValue += pPartKeyValue;
             jenv_->ReleaseStringUTFChars(jPartKeyValue, pPartKeyValue);
             jenv_->DeleteLocalRef(jPartKeyValue);
          }
          NAString location(pSdEntries[0], heap);
          location += "/";
          location += pPartName;
          struct hive_sd_desc* partSdDesc = new (heap)
                struct hive_sd_desc(heap, 0, //SdID
                            location.data(),
                            creationTs,
                            numBuckets, // numBuckets
                            pSdEntries[1], // input format
                            pSdEntries[2], // output format
                            pSdEntries[5],  // null format
                            hive_sd_desc::PARTN_SD,
                            colsDesc,
                            sortColsDesc,
                            bucketColsDesc,
                            fieldTerminator,
                            recordTerminator,
                            isCompressed,
                            partKeyValue.data());
          lastSd->next_ = partSdDesc;
          lastSd = partSdDesc;                  
          jenv_->DeleteLocalRef(jPartKeyValues);
          jenv_->ReleaseStringUTFChars(jPartName, pPartName);
          jenv_->DeleteLocalRef(jPartName);
      }
   }    
   
   for (int i = 0; i < 8 ; i++) {
      if (jSdEntries[i] != NULL) {
         jenv_->ReleaseStringUTFChars(jSdEntries[i], pSdEntries[i]);
         jenv_->DeleteLocalRef(jSdEntries[i]);
      }
   }
   sdDesc = tableSdDesc;  
   return HVC_OK; 
}

HVC_RetCode HiveClient_JNI::populateColumns(NAHeap *heap, hive_column_desc* &columns)
{
   HVC_RetCode hvcRetcode;

   if (colInfo_ == NULL) {
      columns = NULL;
      return HVC_OK;
   }
   struct hive_column_desc* result = NULL;
   struct hive_column_desc* last = result;

   jint numCols = jenv_->GetArrayLength(colInfo_);
   jstring jColDetails[2];
   const char *pColDetails[2];
   for (int colIdx = 0 ; colIdx < numCols ; colIdx++) {
      jobjectArray jCol = (jobjectArray)jenv_->GetObjectArrayElement(colInfo_, colIdx);
      jColDetails[0] = (jstring)jenv_->GetObjectArrayElement(jCol, org_trafodion_sql_HiveClient_Col_NAME);
      jColDetails[1] = (jstring)jenv_->GetObjectArrayElement(jCol, org_trafodion_sql_HiveClient_Col_TYPE);
      pColDetails[0] = jenv_->GetStringUTFChars(jColDetails[0], NULL); 
      pColDetails[1] = jenv_->GetStringUTFChars(jColDetails[1], NULL);
      struct hive_column_desc* newCol = new (heap)
           struct hive_column_desc(heap, 0,
                                pColDetails[0],
                                pColDetails[1],
                                colIdx);
       if ( result == NULL ) {
        last = result = newCol;
      } else {
        last->next_ = newCol;
        last = newCol;
      }
      for (int i = 0; i < 2 ; i++) {
         jenv_->ReleaseStringUTFChars(jColDetails[i], pColDetails[i]);
         jenv_->DeleteLocalRef(jColDetails[i]);
      }
      jenv_->DeleteLocalRef(jCol);
   } 
   columns = result;
   return HVC_OK;
}

HVC_RetCode HiveClient_JNI::populatePartKeyColumns(NAHeap *heap, hive_pkey_desc* &columns)
{
   HVC_RetCode hvcRetcode;
   
   if (partKeyInfo_ == NULL) {
      columns = NULL;
      return HVC_OK;
   }
   struct hive_pkey_desc* result = NULL;
   struct hive_pkey_desc* last = result;

   jint numCols = jenv_->GetArrayLength(partKeyInfo_);
   jstring jColDetails[2];
   const char *pColDetails[2];
   for (int colIdx = 0 ; colIdx < numCols ; colIdx++) {
      jobjectArray jCol = (jobjectArray)jenv_->GetObjectArrayElement(partKeyInfo_, colIdx);
      jColDetails[0] = (jstring)jenv_->GetObjectArrayElement(jCol, org_trafodion_sql_HiveClient_Col_NAME);
      jColDetails[1] = (jstring)jenv_->GetObjectArrayElement(jCol, org_trafodion_sql_HiveClient_Col_TYPE);
      pColDetails[0] = jenv_->GetStringUTFChars(jColDetails[0], NULL); 
      pColDetails[1] = jenv_->GetStringUTFChars(jColDetails[1], NULL);
      struct hive_pkey_desc* newCol = new (heap)
           struct hive_pkey_desc(heap, pColDetails[0],
                                pColDetails[1],
                                colIdx);
       if ( result == NULL ) {
        last = result = newCol;
      } else {
        last->next_ = newCol;
        last = newCol;
      }
      for (int i = 0; i < 2 ; i++) {
         jenv_->ReleaseStringUTFChars(jColDetails[i], pColDetails[i]);
         jenv_->DeleteLocalRef(jColDetails[i]);
      }
      jenv_->DeleteLocalRef(jCol);
   } 
   columns = result;
   return HVC_OK;
}

HVC_RetCode HiveClient_JNI::populateSortColumns(NAHeap *heap, hive_skey_desc* &sortColsDesc)
{
   HVC_RetCode hvcRetcode;
   
   if (sortCols_ == NULL) {
      sortColsDesc = NULL;
      return HVC_OK;
   }
   struct hive_skey_desc* result = NULL;
   struct hive_skey_desc* last = result;

   jint numCols = jenv_->GetArrayLength(sortCols_);
   jstring jColName;
   const char *pColName;
   jint *pSortColsOrder = jenv_->GetIntArrayElements(sortColsOrder_, NULL);
   for (int colIdx = 0 ; colIdx < numCols ; colIdx++) {
      jColName = (jstring)jenv_->GetObjectArrayElement(sortCols_, colIdx);
      pColName = jenv_->GetStringUTFChars(jColName, NULL); 
      struct hive_skey_desc* newCol = new (heap)
           struct hive_skey_desc(heap, pColName,
                                pSortColsOrder[colIdx],
                                colIdx);
       if ( result == NULL ) {
        last = result = newCol;
      } else {
        last->next_ = newCol;
        last = newCol;
      }
      jenv_->ReleaseStringUTFChars(jColName, pColName);
      jenv_->DeleteLocalRef(jColName);
   } 
   jenv_->ReleaseIntArrayElements(sortColsOrder_, pSortColsOrder, JNI_ABORT);
   sortColsDesc = result;
   return HVC_OK;
}

HVC_RetCode HiveClient_JNI::populateBucketColumns(NAHeap *heap, hive_bkey_desc* &bucketColsDesc)
{
   HVC_RetCode hvcRetcode;
   
   if (bucketCols_ == NULL) {
      bucketColsDesc = NULL;
      return HVC_OK;
   }
   struct hive_bkey_desc* result = NULL;
   struct hive_bkey_desc* last = result;

   jint numCols = jenv_->GetArrayLength(bucketCols_);
   jstring jColName;
   const char *pColName;
   for (int colIdx = 0 ; colIdx < numCols ; colIdx++) {
      jColName = (jstring)jenv_->GetObjectArrayElement(bucketCols_, colIdx);
      pColName = jenv_->GetStringUTFChars(jColName, NULL); 
      struct hive_bkey_desc* newCol = new (heap)
           struct hive_bkey_desc(heap, pColName,
                                colIdx);
       if ( result == NULL ) {
        last = result = newCol;
      } else {
        last->next_ = newCol;
        last = newCol;
      }
      jenv_->ReleaseStringUTFChars(jColName, pColName);
      jenv_->DeleteLocalRef(jColName);
   } 
   bucketColsDesc = result;
   return HVC_OK;
}

HVC_RetCode HiveClient_JNI::populateTableParams(NAHeap *heap, hive_sd_desc *sd, hive_tblparams_desc* &tblParamsDesc)
{
   if (paramsKeys_ == NULL) {
      tblParamsDesc = NULL;
      return HVC_OK;
   }
  
   const char **paramsKey;
   const char *orcParamsKey[] = {"orc.block.padding", "orc.stripe.size", "orc.compress", 
                            "orc.row.index.stride", "orc.bloom.filter.columns", "orc.bloom.filter.fpp",
                            "orc.create.index", NULL}; 
   const char *parquetParamsKey[] = {"parquet.block.size", "parquet.page.size", "parquet.compression",  
                            "parquet.enable.dictionary", "parquet.dictionary.page.size", "parquet.writer.max-padding", 
                            NULL};
   if (sd->isOrcFile())
      paramsKey = orcParamsKey;
   else if (sd->isParquetFile())
      paramsKey = parquetParamsKey;
   else {
      tblParamsDesc = NULL;
      return HVC_OK;
   }
   Int32 orcBlockPadding = 1;
   Int64 orcStripeSize = ORC_DEFAULT_STRIPE_SIZE;
   Int32 orcRowIndexStride = ORC_DEFAULT_ROW_INDEX_STRIDE;
   const char *orcCompression = ORC_DEFAULT_COMPRESSION;
   const char *orcBloomFilterColumns = NULL;
   double orcBloomFilterFPP = ORC_DEFAULT_BLOOM_FILTER_FPP;
   NABoolean orcCreateIndex = TRUE;

   NABoolean parquetEnableDictionary = FALSE;
   Int64 parquetBlockSize = PARQUET_DEFAULT_BLOCK_SIZE;
   Int32 parquetPageSize = PARQUET_DEFAULT_PAGE_SIZE;
   const char *parquetCompression = PARQUET_DEFAULT_COMPRESSION;
   Int64 parquetDictionaryPageSize = PARQUET_DEFAULT_DICTIONARY_PAGE_SIZE;
   Int32 parquetWriterMaxPadding = 0;

   NAString tblParamsStr(heap);
   const char *pParamsValue[7]; 
   jstring jParamsValue[7];
   for (int i = 0 ; i < 7 ; i++) {
      pParamsValue[i] = NULL;
      jParamsValue[i] = NULL;
   } 
   int numParams = jenv_->GetArrayLength(paramsKeys_);
   for (int paramNo = 0 ; paramNo < numParams; paramNo++) {
      jstring jTmpParamsKey = (jstring)jenv_->GetObjectArrayElement(paramsKeys_, paramNo);
      jstring jTmpParamsValue = (jstring)jenv_->GetObjectArrayElement(paramsValues_, paramNo);
      const char *pTmpParamsKey = jenv_->GetStringUTFChars(jTmpParamsKey, NULL); 
      const char *pTmpParamsValue = jenv_->GetStringUTFChars(jTmpParamsValue, NULL); 
      bool paramFound = false;
      int  paramFoundKeyIdx;
      for (int paramsKeyIdx = 0; paramsKey[paramsKeyIdx] != NULL ; paramsKeyIdx++) {
         if (strcmp(paramsKey[paramsKeyIdx], pTmpParamsKey) == 0) {
            paramFound = true;
            paramFoundKeyIdx = paramsKeyIdx;
            break;
         }
      } 
      if (paramFound) {
         jParamsValue[paramFoundKeyIdx] = jTmpParamsValue; 
         pParamsValue[paramFoundKeyIdx] = pTmpParamsValue; 
         tblParamsStr += pTmpParamsKey;
         tblParamsStr += "=";  
         tblParamsStr += pTmpParamsValue;
         tblParamsStr += "|";  
      } else {
         jenv_->ReleaseStringUTFChars(jTmpParamsValue, pTmpParamsValue);
         jenv_->DeleteLocalRef(jTmpParamsValue);
      }      
      jenv_->ReleaseStringUTFChars(jTmpParamsKey, pTmpParamsKey);
      jenv_->DeleteLocalRef(jTmpParamsKey);
   }
  
   if (sd->isOrcFile()) {
      if (pParamsValue[0] != NULL) {
         if (strcmp(pParamsValue[0], "true") == 0)
            orcBlockPadding = TRUE;
         else
            orcBlockPadding = FALSE;
      }
      if (pParamsValue[1] != NULL) 
         orcStripeSize = atol(pParamsValue[1]);
      if (pParamsValue[2] != NULL) 
         orcRowIndexStride = atoi(pParamsValue[2]);
      if (pParamsValue[3] != NULL) 
         orcCompression = pParamsValue[3];
      orcBloomFilterColumns = pParamsValue[4];
      if (pParamsValue[5] != NULL) 
         orcBloomFilterFPP = atof(pParamsValue[5]);
      if (pParamsValue[6] != NULL) {
         if (strcmp(pParamsValue[6], "true") == 0) 
            orcCreateIndex = TRUE;
         else
            orcCreateIndex = FALSE;
      }
      tblParamsDesc  = new (heap)
         struct hive_tblparams_desc(heap, 
         tblParamsStr.data(),
         orcBlockPadding,
         orcStripeSize, 
         orcRowIndexStride,
         orcCompression,
         orcBloomFilterColumns,
         orcBloomFilterFPP,
         orcCreateIndex);

   }
   else
   if (sd->isParquetFile()) {
      if (pParamsValue[0] != NULL) 
         parquetBlockSize = atol(pParamsValue[1]);
      if (pParamsValue[1] != NULL) 
         parquetPageSize = atoi(pParamsValue[1]);
      if (pParamsValue[2] != NULL) 
         parquetCompression = pParamsValue[2];
      if (pParamsValue[3] != NULL) {
         if (strcmp(pParamsValue[3], "true") == 0) 
            parquetEnableDictionary = TRUE;
         else
            parquetEnableDictionary = FALSE;
      }
      if (pParamsValue[4] != NULL) 
         parquetDictionaryPageSize = atol(pParamsValue[4]);
      if (pParamsValue[5] != NULL) 
         parquetWriterMaxPadding = atol(pParamsValue[5]);
      tblParamsDesc  = new (heap)
           struct hive_tblparams_desc(heap, 
         tblParamsStr,
         parquetWriterMaxPadding,
         parquetBlockSize,
         parquetPageSize,
         parquetCompression,
         NULL,
         parquetDictionaryPageSize,
         parquetEnableDictionary);
   } 
   else
      tblParamsDesc = NULL;

   for (int i = 0; i < 7 ; i++) {
      if (jParamsValue[i] != NULL) {
         jenv_->ReleaseStringUTFChars(jParamsValue[i], pParamsValue[i]);
         jenv_->DeleteLocalRef(jParamsValue[i]);
      }
   }
   return HVC_OK;
}

//////////////////////////////////////////////////////////////////////////////
// 
////////////////////////////////////////////////////////////////////////////  
void HiveClient_JNI::logIt(const char* str)
{
  QRLogger::log(CAT_SQL_HDFS, LL_DEBUG, str);
}