Sq3LiteC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
#pragma once
 
#include "Sq3Call_cc.hh"
 
namespace ccsq3lite {
 
/*
  inline MK_PTR Sq3LiteC::Sq3LiteC_selfCreateTLS(MK_OBJ obj) {
    return new Sq3LiteC(obj);
  }
 
  inline MK_PTR Sq3LiteC::Sq3LiteC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
    MK_BUF buf = reinterpret_cast<MK_BUF>(obj);
    return MkOBJ_R(buf).obj_protect.isLocal ? Sq3LiteC_selfCreateTLS(obj) : new Sq3LiteC(obj);
  }
*/
 
/*
  inline void MK_DECL Sq3LiteC::Exec (MK_STRN sql, Sq3LiteExecSCB callback)  {
    MK_UNUSED auto sq3lite = getLITE();
    MkRtSetup_X(sq3lite);
    auto callback_ptr = Sq3LiteExecCallbackC::Create(MK_RT_CALL MkOBJ(sq3lite), callback);
    enum MkErrorE errVal = Sq3LiteExec(sq3lite, sql, Sq3LiteExecCallbackC::Call, callback_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
  
  inline void MK_DECL Sq3LiteC::Exec (const std::string& sql, Sq3LiteExecSCB callback)  {
    MK_UNUSED auto sq3lite = getLITE();
    MkRtSetup_X(sq3lite);
    const MK_STRN sql_hdl = sql.c_str();
    auto callback_ptr = Sq3LiteExecCallbackC::Create(MK_RT_CALL MkOBJ(sq3lite), callback);
    enum MkErrorE errVal = Sq3LiteExec(sq3lite, sql_hdl, Sq3LiteExecCallbackC::Call, callback_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
  
  inline void MK_DECL Sq3LiteC::Exec (MK_STRN sql, Sq3LiteExecIF* callback)  {
    MK_UNUSED auto sq3lite = getLITE();
    MkRtSetup_X(sq3lite);
    auto callback_ptr = Sq3LiteExecCallbackC::Create(MK_RT_CALL MkOBJ(sq3lite), callback);
    enum MkErrorE errVal = Sq3LiteExec(sq3lite, sql, Sq3LiteExecCallbackC::Call, callback_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
  
  inline void MK_DECL Sq3LiteC::Exec (const std::string& sql, Sq3LiteExecIF* callback)  {
    MK_UNUSED auto sq3lite = getLITE();
    MkRtSetup_X(sq3lite);
    const MK_STRN sql_hdl = sql.c_str();
    auto callback_ptr = Sq3LiteExecCallbackC::Create(MK_RT_CALL MkOBJ(sq3lite), callback);
    enum MkErrorE errVal = Sq3LiteExec(sq3lite, sql_hdl, Sq3LiteExecCallbackC::Call, callback_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
*/
 
  //   BEGIN-Sq3LiteC - created by 'cc_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Class-Export,sc_
 
  inline Sq3LiteC* Sq3LiteC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    SQ3_LITE __retVal__L = Sq3LiteHandleResolve(netHdl);
    return Sq3LiteC::Sq3LiteC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Class-Export,om_
 
  // skip class-overload: HandleGet = Sq3LiteHandleGet → MkObjectHandleGet
 
  // Sq3LiteC_Class_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Class-Introspection,oc_
 
  inline Sq3LiteC* Sq3LiteC::Next ()  {
    MK_UNUSED auto lite = getLITE();
    SQ3_LITE __retVal__L = Sq3LiteNext(lite);
    return Sq3LiteC::Sq3LiteC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline Sq3LiteC* Sq3LiteC::Prev ()  {
    MK_UNUSED auto lite = getLITE();
    SQ3_LITE __retVal__L = Sq3LitePrev(lite);
    return Sq3LiteC::Sq3LiteC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Class-Introspection,sc_
 
  inline Sq3LiteC* Sq3LiteC::Instances ()  {
    MkRtSetup_NULL;
    SQ3_LITE __retVal__L = Sq3LiteInstances();
    return Sq3LiteC::Sq3LiteC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // Sq3LiteC_Class_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Class-Misc,sc_
 
  inline Sq3LiteC* Sq3LiteC::GetNull ()  {
    MkRtSetup_NULL;
    SQ3_LITE __retVal__L = Sq3LiteGetNull();
    return Sq3LiteC::Sq3LiteC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // Sq3LiteC_Class_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Config,om_
 
  inline void Sq3LiteC::BusyTimeout (MK_I32 ms)  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteBusyTimeout(sq3lite, ms);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::DeclareVtab (MK_STRN zSQL)  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteDeclareVtab(sq3lite, zSQL);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::DeclareVtab (const std::string& zSQL)  {
    MK_UNUSED auto sq3lite = getLITE();
    const MK_STRN zSQL_hdl = zSQL.c_str();
    enum MkErrorE errVal = Sq3LiteDeclareVtab(sq3lite, zSQL_hdl);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::ExtendedResultCodes (MK_I32 onoff)  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteExtendedResultCodes(sq3lite, onoff);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::Limit (Sq3LimitE id, MK_I32 newVal)  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteLimit(sq3lite, id, newVal);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  // Sq3LiteC_Config_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Error,om_
 
  inline Sq3ErrorE Sq3LiteC::ErrCode ()  {
    MK_UNUSED auto db = getLITE();
    enum Sq3ErrorE __retVal__L = Sq3LiteErrCode(db);
    return __retVal__L;
  }
 
  inline MK_STRN Sq3LiteC::ErrMsg ()  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_STRN __retVal__L = Sq3LiteErrMsg(sq3lite);
    return __retVal__L;
  }
 
  inline void Sq3LiteC::ErrorOffset ()  {
    MK_UNUSED auto db = getLITE();
    enum MkErrorE errVal = Sq3LiteErrorOffset(db);
    MkErrorC_Check(db, errVal);
  }
 
  inline Sq3ExtendetResultCodesE Sq3LiteC::ExtendetErrCode ()  {
    MK_UNUSED auto db = getLITE();
    enum Sq3ExtendetResultCodesE __retVal__L = Sq3LiteExtendetErrCode(db);
    return __retVal__L;
  }
 
  inline void Sq3LiteC::SystemErrno ()  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteSystemErrno(sq3lite);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Error,sm_
 
  inline MK_STRN Sq3LiteC::ErrStr (MK_I32 arg0)  {
    MkRtSetup_NULL;
    MK_STRN __retVal__L = Sq3LiteErrStr(arg0);
    return __retVal__L;
  }
 
  // Sq3LiteC_Error_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Execution,om_
 
  inline void Sq3LiteC::ExecV2 (MK_STRN sql, Sq3LiteExecV2IF* callback)  {
    MK_UNUSED auto sq3lite = getLITE();
    auto callback_call = Sq3LiteExecV2CallbackC::Call;
    auto callback_ptr = Sq3LiteExecV2CallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) callback_call = NULL;
    enum MkErrorE errVal = Sq3LiteExecV2(sq3lite, sql, callback_call, callback_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::ExecV2 (const std::string& sql, Sq3LiteExecV2IF* callback)  {
    MK_UNUSED auto sq3lite = getLITE();
    auto callback_call = Sq3LiteExecV2CallbackC::Call;
    const MK_STRN sql_hdl = sql.c_str();
    auto callback_ptr = Sq3LiteExecV2CallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) callback_call = NULL;
    enum MkErrorE errVal = Sq3LiteExecV2(sq3lite, sql_hdl, callback_call, callback_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::ExecV2 (MK_STRN sql, Sq3LiteExecV2SCB callback)  {
    MK_UNUSED auto sq3lite = getLITE();
    auto callback_call = Sq3LiteExecV2CallbackC::Call;
    auto callback_ptr = Sq3LiteExecV2CallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) callback_call = NULL;
    enum MkErrorE errVal = Sq3LiteExecV2(sq3lite, sql, callback_call, callback_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::ExecV2 (const std::string& sql, Sq3LiteExecV2SCB callback)  {
    MK_UNUSED auto sq3lite = getLITE();
    auto callback_call = Sq3LiteExecV2CallbackC::Call;
    const MK_STRN sql_hdl = sql.c_str();
    auto callback_ptr = Sq3LiteExecV2CallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) callback_call = NULL;
    enum MkErrorE errVal = Sq3LiteExecV2(sq3lite, sql_hdl, callback_call, callback_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::Exec (MK_STRN sql, Sq3LiteExecIF* callback_data)  {
    MK_UNUSED auto sq3lite = getLITE();
    auto callback_call = Sq3LiteExecCallbackC::Call;
    auto callback_data_ptr = Sq3LiteExecCallbackC::Create(MK_RT_CALL callback_data, this);
    if (callback_data_ptr == NULL) callback_call = NULL;
    enum MkErrorE errVal = Sq3LiteExec(sq3lite, sql, callback_call, callback_data_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::Exec (const std::string& sql, Sq3LiteExecIF* callback_data)  {
    MK_UNUSED auto sq3lite = getLITE();
    auto callback_call = Sq3LiteExecCallbackC::Call;
    const MK_STRN sql_hdl = sql.c_str();
    auto callback_data_ptr = Sq3LiteExecCallbackC::Create(MK_RT_CALL callback_data, this);
    if (callback_data_ptr == NULL) callback_call = NULL;
    enum MkErrorE errVal = Sq3LiteExec(sq3lite, sql_hdl, callback_call, callback_data_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::Exec (MK_STRN sql, Sq3LiteExecSCB callback_data)  {
    MK_UNUSED auto sq3lite = getLITE();
    auto callback_call = Sq3LiteExecCallbackC::Call;
    auto callback_data_ptr = Sq3LiteExecCallbackC::Create(MK_RT_CALL callback_data, this);
    if (callback_data_ptr == NULL) callback_call = NULL;
    enum MkErrorE errVal = Sq3LiteExec(sq3lite, sql, callback_call, callback_data_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::Exec (const std::string& sql, Sq3LiteExecSCB callback_data)  {
    MK_UNUSED auto sq3lite = getLITE();
    auto callback_call = Sq3LiteExecCallbackC::Call;
    const MK_STRN sql_hdl = sql.c_str();
    auto callback_data_ptr = Sq3LiteExecCallbackC::Create(MK_RT_CALL callback_data, this);
    if (callback_data_ptr == NULL) callback_call = NULL;
    enum MkErrorE errVal = Sq3LiteExec(sq3lite, sql_hdl, callback_call, callback_data_ptr);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Execution,sm_
 
  inline void Sq3LiteC::Sleep (MK_I32 arg0)  {
    MkRtSetup_NULL;
    enum MkErrorE errVal = Sq3LiteSleep(arg0);
    MkErrorC_Check(NULL, errVal);
  }
 
  // Sq3LiteC_Execution_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Info,om_
 
  inline MK_I32 Sq3LiteC::GetAutocommit ()  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_I32 __retVal__L = Sq3LiteGetAutocommit(sq3lite);
    return __retVal__L;
  }
 
  inline MK_I64 Sq3LiteC::LastInsertRowid ()  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_I64 __retVal__L = Sq3LiteLastInsertRowid(sq3lite);
    return __retVal__L;
  }
 
  inline void Sq3LiteC::TxnState (MK_STRN zSchema)  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteTxnState(sq3lite, zSchema);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::TxnState (const std::string& zSchema)  {
    MK_UNUSED auto sq3lite = getLITE();
    const MK_STRN zSchema_hdl = zSchema.c_str();
    enum MkErrorE errVal = Sq3LiteTxnState(sq3lite, zSchema_hdl);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::VtabOnConflict ()  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteVtabOnConflict(sq3lite);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  // Sq3LiteC_Info_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Misc,oco
 
  inline MkBufferListC* Sq3LiteC::DbStatusBFL (Sq3DbStatusE op, MK_BOOL resetFlg)  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_BFL val_out;
    enum MkErrorE errVal = Sq3LiteDbStatusBFL(sq3lite, op, &val_out, resetFlg);
    MkErrorC_Check(sq3lite, errVal);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL val_out);
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Misc,om_
 
  inline void Sq3LiteC::DbCacheflush ()  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteDbCacheflush(sq3lite);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline SQ3_FILENAME Sq3LiteC::DbFilename (MK_STRN zDbName)  {
    MK_UNUSED auto db = getLITE();
    SQ3_FILENAME __retVal__L = Sq3LiteDbFilename(db, zDbName);
    return __retVal__L;
  }
 
  inline SQ3_FILENAME Sq3LiteC::DbFilename (const std::string& zDbName)  {
    MK_UNUSED auto db = getLITE();
    const MK_STRN zDbName_hdl = zDbName.c_str();
    SQ3_FILENAME __retVal__L = Sq3LiteDbFilename(db, zDbName_hdl);
    return __retVal__L;
  }
 
  inline MK_STRN Sq3LiteC::DbName (MK_I32 N)  {
    MK_UNUSED auto db = getLITE();
    MK_STRN __retVal__L = Sq3LiteDbName(db, N);
    return __retVal__L;
  }
 
  inline void Sq3LiteC::DbReadonly (MK_STRN zDbName)  {
    MK_UNUSED auto db = getLITE();
    enum MkErrorE errVal = Sq3LiteDbReadonly(db, zDbName);
    MkErrorC_Check(db, errVal);
  }
 
  inline void Sq3LiteC::DbReadonly (const std::string& zDbName)  {
    MK_UNUSED auto db = getLITE();
    const MK_STRN zDbName_hdl = zDbName.c_str();
    enum MkErrorE errVal = Sq3LiteDbReadonly(db, zDbName_hdl);
    MkErrorC_Check(db, errVal);
  }
 
  inline void Sq3LiteC::DbReleaseMemory ()  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteDbReleaseMemory(sq3lite);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::Deserialize (MK_STRN zSchema, MK_BNP pData, Sq3DeSerializeEF mFlags)  {
    MK_UNUSED auto sq3lite = getLITE();
    const MkBinaryR pData_ref = MkBinaryCreate(pData.first,pData.second);
    enum MkErrorE errVal = Sq3LiteDeserialize(sq3lite, zSchema, pData_ref, mFlags);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::Deserialize (const std::string& zSchema, MK_BNP pData, Sq3DeSerializeEF mFlags)  {
    MK_UNUSED auto sq3lite = getLITE();
    const MK_STRN zSchema_hdl = zSchema.c_str();
    const MkBinaryR pData_ref = MkBinaryCreate(pData.first,pData.second);
    enum MkErrorE errVal = Sq3LiteDeserialize(sq3lite, zSchema_hdl, pData_ref, mFlags);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::DropModules (MkBufferListC* azKeepBfl)  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_BFL azKeepBfl_hdl = MkBufferListC::getBFL(azKeepBfl);
    enum MkErrorE errVal = Sq3LiteDropModules(sq3lite, azKeepBfl_hdl);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::DropModules (const MkBufferListC& azKeepBfl)  {
    MK_UNUSED auto sq3lite = getLITE();
    const MK_BFL azKeepBfl_hdl = MkBufferListC::getBFL(azKeepBfl);
    enum MkErrorE errVal = Sq3LiteDropModules(sq3lite, azKeepBfl_hdl);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  // skip class-overload: Log = Sq3LiteLog → MkObjectLog
 
  // skip class-overload: Log = Sq3LiteLog → MkObjectLog
 
  inline void Sq3LiteC::OverloadFunction (MK_STRN zFuncName, MK_I32 nArg)  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteOverloadFunction(sq3lite, zFuncName, nArg);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline void Sq3LiteC::OverloadFunction (const std::string& zFuncName, MK_I32 nArg)  {
    MK_UNUSED auto sq3lite = getLITE();
    const MK_STRN zFuncName_hdl = zFuncName.c_str();
    enum MkErrorE errVal = Sq3LiteOverloadFunction(sq3lite, zFuncName_hdl, nArg);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  inline MK_BNP Sq3LiteC::Serialize (MK_STRN zSchema, Sq3SerializeE mFlags)  {
    MK_UNUSED auto sq3lite = getLITE();
    MkBinaryR __retVal__L = Sq3LiteSerialize(sq3lite, zSchema, mFlags);
    return std::make_pair(MkBinaryGetSize(__retVal__L),MkBinaryGetData(__retVal__L));
  }
 
  inline MK_BNP Sq3LiteC::Serialize (const std::string& zSchema, Sq3SerializeE mFlags)  {
    MK_UNUSED auto sq3lite = getLITE();
    const MK_STRN zSchema_hdl = zSchema.c_str();
    MkBinaryR __retVal__L = Sq3LiteSerialize(sq3lite, zSchema_hdl, mFlags);
    return std::make_pair(MkBinaryGetSize(__retVal__L),MkBinaryGetData(__retVal__L));
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Misc,omo
 
  inline std::tuple<MK_I32,MK_I32> Sq3LiteC::DbStatus (Sq3DbStatusE op, MK_BOOL resetFlg)  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_I32 pCur;
    MK_I32 pHiwtr;
    enum MkErrorE errVal = Sq3LiteDbStatus(sq3lite, op, &pCur, &pHiwtr, resetFlg);
    MkErrorC_Check(sq3lite, errVal);
    std::tuple<MK_I32,MK_I32> __retVal__L = {pCur,pHiwtr};
    return __retVal__L;
  }
 
  inline std::tuple<MK_STRN,MK_STRN,MK_I32,MK_I32,MK_I32> Sq3LiteC::TableColumnMetadata (MK_STRN zDbName, MK_STRN zTableName, MK_STRN zColumnName)  {
    MK_UNUSED auto db = getLITE();
    MK_STRN pzDataType;
    MK_STRN pzCollSeq;
    MK_I32 pNotNull;
    MK_I32 pPrimaryKey;
    MK_I32 pAutoinc;
    enum MkErrorE errVal = Sq3LiteTableColumnMetadata(db, zDbName, zTableName, zColumnName, &pzDataType, &pzCollSeq, &pNotNull, &pPrimaryKey, &pAutoinc);
    MkErrorC_Check(db, errVal);
    std::tuple<MK_STRN,MK_STRN,MK_I32,MK_I32,MK_I32> __retVal__L = {pzDataType,pzCollSeq,pNotNull,pPrimaryKey,pAutoinc};
    return __retVal__L;
  }
 
  inline std::tuple<MK_STRN,MK_STRN,MK_I32,MK_I32,MK_I32> Sq3LiteC::TableColumnMetadata (const std::string& zDbName, const std::string& zTableName, const std::string& zColumnName)  {
    MK_UNUSED auto db = getLITE();
    MK_STRN pzDataType;
    MK_STRN pzCollSeq;
    MK_I32 pNotNull;
    MK_I32 pPrimaryKey;
    MK_I32 pAutoinc;
    const MK_STRN zDbName_hdl = zDbName.c_str();
    const MK_STRN zTableName_hdl = zTableName.c_str();
    const MK_STRN zColumnName_hdl = zColumnName.c_str();
    enum MkErrorE errVal = Sq3LiteTableColumnMetadata(db, zDbName_hdl, zTableName_hdl, zColumnName_hdl, &pzDataType, &pzCollSeq, &pNotNull, &pPrimaryKey, &pAutoinc);
    MkErrorC_Check(db, errVal);
    std::tuple<MK_STRN,MK_STRN,MK_I32,MK_I32,MK_I32> __retVal__L = {pzDataType,pzCollSeq,pNotNull,pPrimaryKey,pAutoinc};
    return __retVal__L;
  }
 
  // Sq3LiteC_Misc_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,om_
 
  inline void Sq3LiteC::WalAutocheckpoint (MK_I32 N)  {
    MK_UNUSED auto db = getLITE();
    enum MkErrorE errVal = Sq3LiteWalAutocheckpoint(db, N);
    MkErrorC_Check(db, errVal);
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,omo
 
  inline std::tuple<MK_I32,MK_I32> Sq3LiteC::WalCheckpointV2 (MK_STRN zDb, MK_I32 eMode)  {
    MK_UNUSED auto db = getLITE();
    MK_I32 pnLog;
    MK_I32 pnCkpt;
    enum MkErrorE errVal = Sq3LiteWalCheckpointV2(db, zDb, eMode, &pnLog, &pnCkpt);
    MkErrorC_Check(db, errVal);
    std::tuple<MK_I32,MK_I32> __retVal__L = {pnLog,pnCkpt};
    return __retVal__L;
  }
 
  inline std::tuple<MK_I32,MK_I32> Sq3LiteC::WalCheckpointV2 (const std::string& zDb, MK_I32 eMode)  {
    MK_UNUSED auto db = getLITE();
    MK_I32 pnLog;
    MK_I32 pnCkpt;
    const MK_STRN zDb_hdl = zDb.c_str();
    enum MkErrorE errVal = Sq3LiteWalCheckpointV2(db, zDb_hdl, eMode, &pnLog, &pnCkpt);
    MkErrorC_Check(db, errVal);
    std::tuple<MK_I32,MK_I32> __retVal__L = {pnLog,pnCkpt};
    return __retVal__L;
  }
 
  // Sq3LiteC_Modify_Wal_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Query,om_
 
  inline void Sq3LiteC::Interrupt ()  {
    MK_UNUSED auto sq3lite = getLITE();
    Sq3LiteInterrupt(sq3lite);
  }
 
  inline MK_BOOL Sq3LiteC::IsInterrupted ()  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_BOOL __retVal__L = Sq3LiteIsInterrupted(sq3lite);
    return __retVal__L;
  }
 
  // Sq3LiteC_Query_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-Row,om_
 
  inline MK_I32 Sq3LiteC::Changes ()  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_I32 __retVal__L = Sq3LiteChanges(sq3lite);
    return __retVal__L;
  }
 
  inline MK_I64 Sq3LiteC::Changes64 ()  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_I64 __retVal__L = Sq3LiteChanges64(sq3lite);
    return __retVal__L;
  }
 
  inline void Sq3LiteC::SetLastInsertRowid (MK_I64 arg1)  {
    MK_UNUSED auto sq3lite = getLITE();
    Sq3LiteSetLastInsertRowid(sq3lite, arg1);
  }
 
  inline MK_I32 Sq3LiteC::TotalChanges ()  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_I32 __retVal__L = Sq3LiteTotalChanges(sq3lite);
    return __retVal__L;
  }
 
  inline MK_I64 Sq3LiteC::TotalChanges64 ()  {
    MK_UNUSED auto sq3lite = getLITE();
    MK_I64 __retVal__L = Sq3LiteTotalChanges64(sq3lite);
    return __retVal__L;
  }
 
  // Sq3LiteC_Row_CC_API
 
 
  // doc-key: Sq3LiteC,Sq3LiteC-TOR,sCo
 
  inline MK_OBJ Sq3LiteC::CTOR (MK_STRN filename, Sq3OpenEF flags, MK_STRN zVfs)  {
    MkRtSetup_NULL;
    SQ3_LITE ppDb;
    enum MkErrorE errVal = Sq3LiteOpenV2(filename, &ppDb, flags, zVfs);
    MkErrorC_Check(NULL, errVal);
    return (MK_OBJ)ppDb;
  }
 
  inline MK_OBJ Sq3LiteC::CTOR (const std::string& filename, Sq3OpenEF flags, MK_STRN zVfs)  {
    MkRtSetup_NULL;
    SQ3_LITE ppDb;
    const MK_STRN filename_hdl = filename.c_str();
    enum MkErrorE errVal = Sq3LiteOpenV2(filename_hdl, &ppDb, flags, zVfs);
    MkErrorC_Check(NULL, errVal);
    return (MK_OBJ)ppDb;
  }
 
  inline Sq3LiteC* Sq3LiteC::OpenV2 (MK_STRN filename, Sq3OpenEF flags, MK_STRN zVfs)  {
    MkRtSetup_NULL;
    SQ3_LITE ppDb;
    enum MkErrorE errVal = Sq3LiteOpenV2(filename, &ppDb, flags, zVfs);
    MkErrorC_Check(NULL, errVal);
    return Sq3LiteC::Sq3LiteC_ObjCreate(MK_RT_CALL ppDb);
  }
 
  inline Sq3LiteC* Sq3LiteC::OpenV2 (const std::string& filename, Sq3OpenEF flags, MK_STRN zVfs)  {
    MkRtSetup_NULL;
    SQ3_LITE ppDb;
    const MK_STRN filename_hdl = filename.c_str();
    enum MkErrorE errVal = Sq3LiteOpenV2(filename_hdl, &ppDb, flags, zVfs);
    MkErrorC_Check(NULL, errVal);
    return Sq3LiteC::Sq3LiteC_ObjCreate(MK_RT_CALL ppDb);
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-TOR,oco
 
  inline Sq3StmtC* Sq3LiteC::PrepareV2 (const std::string& zSql)  {
    MK_UNUSED auto db = getLITE();
    SQ3_STMT ppStmt;
    const MkStringR zSql_ref = MkStringCreate((MK_NUM)zSql.size(),zSql.c_str());
    enum MkErrorE errVal = Sq3LitePrepareV2(db, zSql_ref, &ppStmt);
    MkErrorC_Check(db, errVal);
    return Sq3StmtC::Sq3StmtC_ObjNew(MK_RT_CALL ppStmt);
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-TOR,om_
 
  inline void Sq3LiteC::CloseV2 ()  {
    MK_UNUSED auto sq3lite = getLITE();
    enum MkErrorE errVal = Sq3LiteCloseV2(sq3lite);
    MkErrorC_Check(sq3lite, errVal);
  }
 
  // Sq3LiteC_TOR_CC_API
 
  //   END-Sq3LiteC - created by 'cc_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
} // END - namespace "ccsq3lite"