Sq3LiteC_jv.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "Sq3LiteC_jv.c"
 
#include "jni_h/jvsq3lite_Sq3LiteC.h"
#include "LibSq3Lite_private_jv.h"
 
 
jobject NS(Sq3LiteC_ObjNew) (MK_RT_ARGS JNIEnv *env, SQ3_LITE hdl) {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, Sq3LiteC_X2obj(hdl)) : MK_GET__NS_NULL(Sq3LiteC));
}
 
MK_UNUSED
static jobject NS(Sq3LiteC_ObjCreate) (MK_RT_ARGS JNIEnv *env, SQ3_LITE hdl) {
  return MK(AtomObjCreate)(MK_RT_CALL env, Sq3LiteC_X2obj(hdl));
}
 
static MK_PTR NS(Sq3LiteC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_Sq3LiteC), NS(MID_Sq3LiteC_INIT), (jlong) obj, JNI_TRUE);
}
 
#define ClassInit \
 
//  printTxt("init: Sq3LiteC");
 
/* LABEL-END */
 
// BEGIN-Sq3LiteC - created by 'jv_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Class-Export,sc_
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  SQ3_LITE __retVal__L = Sq3LiteHandleResolve(netHdl);
  jobject __retVal__S = SQ3(Sq3LiteC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-Class-Export,om_
 
// skip class-overload: HandleGet = Sq3LiteHandleGet → MkObjectHandleGet
 
// Sq3LiteC_Class_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Class-Introspection,oc_
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_Next (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  SQ3_LITE __retVal__L = Sq3LiteNext(hdl);
  jobject __retVal__S = SQ3(Sq3LiteC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_Prev (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  SQ3_LITE __retVal__L = Sq3LitePrev(hdl);
  jobject __retVal__S = SQ3(Sq3LiteC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-Class-Introspection,sc_
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_Instances (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  SQ3_LITE __retVal__L = Sq3LiteInstances();
  jobject __retVal__S = SQ3(Sq3LiteC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// Sq3LiteC_Class_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Class-Misc,sc_
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_GetNull (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  SQ3_LITE __retVal__L = Sq3LiteGetNull();
  jobject __retVal__S = SQ3(Sq3LiteC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// Sq3LiteC_Class_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Config,om_
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_BusyTimeout (JNIEnv *env, jobject self, jint ms)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteBusyTimeout(hdl, ms);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_DeclareVtab (JNIEnv *env, jobject self, jstring zSQL)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN zSQL_ptr = (zSQL?(*env)->GetStringUTFChars(env,zSQL,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteDeclareVtab(hdl, zSQL_ptr);
  MkErrorC_Check(hdl, errVal)
  if (zSQL_ptr) (*env)->ReleaseStringUTFChars(env,zSQL,zSQL_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_ExtendedResultCodes (JNIEnv *env, jobject self, jint onoff)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteExtendedResultCodes(hdl, onoff);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_Limit (JNIEnv *env, jobject self, jobject id, jint newVal)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum Sq3LimitE id_e = MK(pGetEnumFromObj)(env, NS(Class_Sq3LimitE), id);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteLimit(hdl, id_e, newVal);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// Sq3LiteC_Config_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Error,om_
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_ErrCode (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum Sq3ErrorE __retVal__L = Sq3LiteErrCode(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,SQ3(Class_Sq3ErrorE),"Ljvsq3lite/Sq3ErrorE;",Sq3ErrorE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvsq3lite_Sq3LiteC_ErrMsg (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = Sq3LiteErrMsg(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_ErrorOffset (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteErrorOffset(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_ExtendetErrCode (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum Sq3ExtendetResultCodesE __retVal__L = Sq3LiteExtendetErrCode(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,SQ3(Class_Sq3ExtendetResultCodesE),"Ljvsq3lite/Sq3ExtendetResultCodesE;",Sq3ExtendetResultCodesE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_SystemErrno (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteSystemErrno(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-Error,sm_
 
JNIEXPORT jstring JNICALL Java_jvsq3lite_Sq3LiteC_ErrStr (JNIEnv *env, jclass class, jint arg0)  {
  MkRtSetup_NULL;
  MK_STRN __retVal__L = Sq3LiteErrStr(arg0);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
}
 
// Sq3LiteC_Error_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Execution,om_
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_Exec (JNIEnv *env, jobject self, jstring sql, jobject callback_data)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  Sq3Fupu_Sq3LiteExec_callback_call callback_call = NS(LiteExecCall);
  MK_STRN sql_ptr = (sql?(*env)->GetStringUTFChars(env,sql,NULL):NULL);
  JavaErrorCheck;
  MK_CBP callback_data_ptr = MK(ProcCreate)(MK_RT_CALL env, callback_data, NULL, NS(MID_callback_data), true);
  JavaErrorCheck;
  if (callback_data_ptr == NULL) callback_call = NULL;
  enum MkErrorE errVal = Sq3LiteExec(hdl, sql_ptr, callback_call, callback_data_ptr);
  MkErrorC_Check(hdl, errVal)
  if (sql_ptr) (*env)->ReleaseStringUTFChars(env,sql,sql_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_ExecV2 (JNIEnv *env, jobject self, jstring sql, jobject callback)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  Sq3LiteExecV2CB callback_call = NS(LiteExecV2Call);
  MK_STRN sql_ptr = (sql?(*env)->GetStringUTFChars(env,sql,NULL):NULL);
  JavaErrorCheck;
  MK_CBP callback_ptr = MK(ProcCreate)(MK_RT_CALL env, callback, NULL, NS(MID_callback), true);
  JavaErrorCheck;
  if (callback_ptr == NULL) callback_call = NULL;
  enum MkErrorE errVal = Sq3LiteExecV2(hdl, sql_ptr, callback_call, callback_ptr);
  MkErrorC_Check(hdl, errVal)
  if (sql_ptr) (*env)->ReleaseStringUTFChars(env,sql,sql_ptr);
error:
  return;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-Execution,sm_
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_Sleep (JNIEnv *env, jclass class, jint arg0)  {
  MkRtSetup_NULL;
  enum MkErrorE errVal = Sq3LiteSleep(arg0);
  MkErrorC_Check(NULL, errVal)
error:
  return;
}
 
// Sq3LiteC_Execution_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Info,om_
 
JNIEXPORT jint JNICALL Java_jvsq3lite_Sq3LiteC_GetAutocommit (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 __retVal__L = Sq3LiteGetAutocommit(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvsq3lite_Sq3LiteC_LastInsertRowid (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I64 __retVal__L = Sq3LiteLastInsertRowid(hdl);
  jlong __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_TxnState (JNIEnv *env, jobject self, jstring zSchema)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN zSchema_ptr = (zSchema?(*env)->GetStringUTFChars(env,zSchema,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteTxnState(hdl, zSchema_ptr);
  MkErrorC_Check(hdl, errVal)
  if (zSchema_ptr) (*env)->ReleaseStringUTFChars(env,zSchema,zSchema_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_VtabOnConflict (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteVtabOnConflict(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// Sq3LiteC_Info_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Misc,oco
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_DbStatusBFL (JNIEnv *env, jobject self, jobject op, jboolean resetFlg)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL val_out;
  enum Sq3DbStatusE op_e = MK(pGetEnumFromObj)(env, NS(Class_Sq3DbStatusE), op);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteDbStatusBFL(hdl, op_e, &val_out, resetFlg);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-Misc,om_
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_DbCacheflush (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteDbCacheflush(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT jstring JNICALL Java_jvsq3lite_Sq3LiteC_DbFilename (JNIEnv *env, jobject self, jstring zDbName)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN zDbName_ptr = (zDbName?(*env)->GetStringUTFChars(env,zDbName,NULL):NULL);
  JavaErrorCheck;
  SQ3_FILENAME __retVal__L = Sq3LiteDbFilename(hdl, zDbName_ptr);
  jstring __retVal__S = JC2O(env,__retVal__L);
  if (zDbName_ptr) (*env)->ReleaseStringUTFChars(env,zDbName,zDbName_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvsq3lite_Sq3LiteC_DbName (JNIEnv *env, jobject self, jint N)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = Sq3LiteDbName(hdl, N);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_DbReadonly (JNIEnv *env, jobject self, jstring zDbName)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN zDbName_ptr = (zDbName?(*env)->GetStringUTFChars(env,zDbName,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteDbReadonly(hdl, zDbName_ptr);
  MkErrorC_Check(hdl, errVal)
  if (zDbName_ptr) (*env)->ReleaseStringUTFChars(env,zDbName,zDbName_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_DbReleaseMemory (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteDbReleaseMemory(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_Deserialize (JNIEnv *env, jobject self, jstring zSchema, jbyteArray pData, jobject mFlags)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN zSchema_ptr = (zSchema?(*env)->GetStringUTFChars(env,zSchema,NULL):NULL);
  JavaErrorCheck;
  MK_BINN pData_data = (MK_BINN) (*env)->GetByteArrayElements(env, pData, NULL);
  JavaErrorCheck;
  MK_SIZE pData_size = (MK_SIZE) (*env)->GetArrayLength (env, pData);
  JavaErrorCheck;
  MkBinaryR pData_ref = MkBinaryCreate(pData_size,pData_data);
  enum Sq3DeSerializeEF mFlags_e = MK(pGetEnumFromObj)(env, NS(Class_Sq3DeSerializeEF), mFlags);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteDeserialize(hdl, zSchema_ptr, pData_ref, mFlags_e);
  MkErrorC_Check(hdl, errVal)
  if (zSchema_ptr) (*env)->ReleaseStringUTFChars(env,zSchema,zSchema_ptr);
  (*env)->ReleaseByteArrayElements(env, pData, (jbyte*)pData_data, JNI_ABORT);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_DropModules (JNIEnv *env, jobject self, jobject azKeepBfl)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL azKeepBfl_hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",azKeepBfl);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteDropModules(hdl, azKeepBfl_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// skip class-overload: Log = Sq3LiteLog → MkObjectLog
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_OverloadFunction (JNIEnv *env, jobject self, jstring zFuncName, jint nArg)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN zFuncName_ptr = (zFuncName?(*env)->GetStringUTFChars(env,zFuncName,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteOverloadFunction(hdl, zFuncName_ptr, nArg);
  MkErrorC_Check(hdl, errVal)
  if (zFuncName_ptr) (*env)->ReleaseStringUTFChars(env,zFuncName,zFuncName_ptr);
error:
  return;
}
 
JNIEXPORT jbyteArray JNICALL Java_jvsq3lite_Sq3LiteC_Serialize (JNIEnv *env, jobject self, jstring zSchema, jobject mFlags)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN zSchema_ptr = (zSchema?(*env)->GetStringUTFChars(env,zSchema,NULL):NULL);
  JavaErrorCheck;
  enum Sq3SerializeE mFlags_e = MK(pGetEnumFromObj)(env, NS(Class_Sq3SerializeE), mFlags);
  JavaErrorCheck;
  MkBinaryR __retVal__L = Sq3LiteSerialize(hdl, zSchema_ptr, mFlags_e);
  jbyteArray __retVal__S = (*env)->NewByteArray(env, (jsize) __retVal__L.size);
  JavaErrorCheck;
  (*env)->SetByteArrayRegion(env,__retVal__S,0,(jsize) __retVal__L.size,(jbyte*)__retVal__L.data);
  JavaErrorCheck;
  if (zSchema_ptr) (*env)->ReleaseStringUTFChars(env,zSchema,zSchema_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-Misc,omo
 
JNIEXPORT jobjectArray JNICALL Java_jvsq3lite_Sq3LiteC_DbStatus (JNIEnv *env, jobject self, jobject op, jboolean resetFlg)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 pCur;
  MK_I32 pHiwtr;
  enum Sq3DbStatusE op_e = MK(pGetEnumFromObj)(env, NS(Class_Sq3DbStatusE), op);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteDbStatus(hdl, op_e, &pCur, &pHiwtr, resetFlg);
  MkErrorC_Check(hdl, errVal)
  jobjectArray __retVal__L = (jobjectArray)(*env)->NewObjectArray(env,2,MK(Class_Integer),NULL);
  (*env)->SetObjectArrayElement(env,__retVal__L,0,pNewIntObj(env,pCur));
  (*env)->SetObjectArrayElement(env,__retVal__L,1,pNewIntObj(env,pHiwtr));
  jobjectArray __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobjectArray JNICALL Java_jvsq3lite_Sq3LiteC_TableColumnMetadata (JNIEnv *env, jobject self, jstring zDbName, jstring zTableName, jstring zColumnName)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN pzDataType;
  MK_STRN pzCollSeq;
  MK_I32 pNotNull;
  MK_I32 pPrimaryKey;
  MK_I32 pAutoinc;
  MK_STRN zDbName_ptr = (zDbName?(*env)->GetStringUTFChars(env,zDbName,NULL):NULL);
  JavaErrorCheck;
  MK_STRN zTableName_ptr = (zTableName?(*env)->GetStringUTFChars(env,zTableName,NULL):NULL);
  JavaErrorCheck;
  MK_STRN zColumnName_ptr = (zColumnName?(*env)->GetStringUTFChars(env,zColumnName,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteTableColumnMetadata(hdl, zDbName_ptr, zTableName_ptr, zColumnName_ptr, &pzDataType, &pzCollSeq, &pNotNull, &pPrimaryKey, &pAutoinc);
  MkErrorC_Check(hdl, errVal)
  jobjectArray __retVal__L = (jobjectArray)(*env)->NewObjectArray(env,5,MK(Class_String),NULL);
  (*env)->SetObjectArrayElement(env,__retVal__L,0,(*env)->NewStringUTF(env,pzDataType));
  (*env)->SetObjectArrayElement(env,__retVal__L,1,(*env)->NewStringUTF(env,pzCollSeq));
  (*env)->SetObjectArrayElement(env,__retVal__L,2,pNewIntObj(env,pNotNull));
  (*env)->SetObjectArrayElement(env,__retVal__L,3,pNewIntObj(env,pPrimaryKey));
  (*env)->SetObjectArrayElement(env,__retVal__L,4,pNewIntObj(env,pAutoinc));
  jobjectArray __retVal__S = __retVal__L;
  if (zDbName_ptr) (*env)->ReleaseStringUTFChars(env,zDbName,zDbName_ptr);
  if (zTableName_ptr) (*env)->ReleaseStringUTFChars(env,zTableName,zTableName_ptr);
  if (zColumnName_ptr) (*env)->ReleaseStringUTFChars(env,zColumnName,zColumnName_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// Sq3LiteC_Misc_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,om_
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_WalAutocheckpoint (JNIEnv *env, jobject self, jint N)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteWalAutocheckpoint(hdl, N);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,omo
 
JNIEXPORT jobjectArray JNICALL Java_jvsq3lite_Sq3LiteC_WalCheckpointV2 (JNIEnv *env, jobject self, jstring zDb, jint eMode)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 pnLog;
  MK_I32 pnCkpt;
  MK_STRN zDb_ptr = (zDb?(*env)->GetStringUTFChars(env,zDb,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteWalCheckpointV2(hdl, zDb_ptr, eMode, &pnLog, &pnCkpt);
  MkErrorC_Check(hdl, errVal)
  jobjectArray __retVal__L = (jobjectArray)(*env)->NewObjectArray(env,2,MK(Class_Integer),NULL);
  (*env)->SetObjectArrayElement(env,__retVal__L,0,pNewIntObj(env,pnLog));
  (*env)->SetObjectArrayElement(env,__retVal__L,1,pNewIntObj(env,pnCkpt));
  jobjectArray __retVal__S = __retVal__L;
  if (zDb_ptr) (*env)->ReleaseStringUTFChars(env,zDb,zDb_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// Sq3LiteC_Modify_Wal_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Query,om_
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_Interrupt (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  Sq3LiteInterrupt(hdl);
error:
  return;
}
 
JNIEXPORT jboolean JNICALL Java_jvsq3lite_Sq3LiteC_IsInterrupted (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = Sq3LiteIsInterrupted(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
// Sq3LiteC_Query_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-Row,om_
 
JNIEXPORT jint JNICALL Java_jvsq3lite_Sq3LiteC_Changes (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 __retVal__L = Sq3LiteChanges(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvsq3lite_Sq3LiteC_Changes64 (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I64 __retVal__L = Sq3LiteChanges64(hdl);
  jlong __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_SetLastInsertRowid (JNIEnv *env, jobject self, jlong arg1)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  Sq3LiteSetLastInsertRowid(hdl, arg1);
error:
  return;
}
 
JNIEXPORT jint JNICALL Java_jvsq3lite_Sq3LiteC_TotalChanges (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 __retVal__L = Sq3LiteTotalChanges(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvsq3lite_Sq3LiteC_TotalChanges64 (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I64 __retVal__L = Sq3LiteTotalChanges64(hdl);
  jlong __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
// Sq3LiteC_Row_JV_API
 
 
// doc-key: Sq3LiteC,Sq3LiteC-TOR,sCo
 
JNIEXPORT jlong JNICALL Java_jvsq3lite_Sq3LiteC_CTOR (JNIEnv *env, jclass class, jstring filename, jobject flags, jstring zVfs)  {
  MkRtSetup_NULL;
  SQ3_LITE ppDb;
  MK_STRN filename_ptr = (filename?(*env)->GetStringUTFChars(env,filename,NULL):NULL);
  JavaErrorCheck;
  enum Sq3OpenEF flags_e = MK(pGetEnumFromObj)(env, NS(Class_Sq3OpenEF), flags);
  JavaErrorCheck;
  MK_STRN zVfs_ptr = (zVfs?(*env)->GetStringUTFChars(env,zVfs,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteOpenV2(filename_ptr, &ppDb, flags_e, zVfs_ptr);
  MkErrorC_Check(NULL, errVal)
  jlong __retVal__S = (jlong)ppDb;
  if (filename_ptr) (*env)->ReleaseStringUTFChars(env,filename,filename_ptr);
  if (zVfs_ptr) (*env)->ReleaseStringUTFChars(env,zVfs,zVfs_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_OpenV2 (JNIEnv *env, jclass class, jstring filename, jobject flags, jstring zVfs)  {
  MkRtSetup_NULL;
  SQ3_LITE ppDb;
  MK_STRN filename_ptr = (filename?(*env)->GetStringUTFChars(env,filename,NULL):NULL);
  JavaErrorCheck;
  enum Sq3OpenEF flags_e = MK(pGetEnumFromObj)(env, NS(Class_Sq3OpenEF), flags);
  JavaErrorCheck;
  MK_STRN zVfs_ptr = (zVfs?(*env)->GetStringUTFChars(env,zVfs,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LiteOpenV2(filename_ptr, &ppDb, flags_e, zVfs_ptr);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = SQ3(Sq3LiteC_ObjCreate)(MK_RT_CALL env,ppDb);
  if (filename_ptr) (*env)->ReleaseStringUTFChars(env,filename,filename_ptr);
  if (zVfs_ptr) (*env)->ReleaseStringUTFChars(env,zVfs,zVfs_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-TOR,oco
 
JNIEXPORT jobject JNICALL Java_jvsq3lite_Sq3LiteC_PrepareV2 (JNIEnv *env, jobject self, jstring zSql)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  SQ3_STMT ppStmt;
  MkStringR zSql_ref = MkStringCreate((*env)->GetStringUTFLength(env,zSql),(zSql?(*env)->GetStringUTFChars(env,zSql,NULL):NULL));
  JavaErrorCheck;
  enum MkErrorE errVal = Sq3LitePrepareV2(hdl, zSql_ref, &ppStmt);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = SQ3(Sq3StmtC_ObjNew)(MK_RT_CALL env,ppStmt);
  if (zSql_ref.ptr) (*env)->ReleaseStringUTFChars(env,zSql,zSql_ref.ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: Sq3LiteC,Sq3LiteC-TOR,om_
 
JNIEXPORT void JNICALL Java_jvsq3lite_Sq3LiteC_CloseV2 (JNIEnv *env, jobject self)  {
  SQ3_LITE hdl = (SQ3_LITE)pObj2Hdl(env,"Sq3LiteC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = Sq3LiteCloseV2(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// Sq3LiteC_TOR_JV_API
 
// END-Sq3LiteC - created by 'jv_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
void NS(Sq3LiteC_Init)(SQ3_RT_ARGS_ONLY) {
  ClassInit
 
  Sq3LiteC_TT->selfCreate        =  NS(Sq3LiteC_selfCreate) ;
  Sq3LiteC_TT->selfUnlink        =  MK(AtomSelfUnlink) ;
}
 
// ====================================================================================================
// OVERLOAD