Sq3LiteC_sq3.h

Go to the documentation of this file.

 
/* LABEL-START */
#pragma once
 
#include "LibSq3Lite_sq3.h"
/* LABEL-END */
 
#include "Sq3LiteC_def_sq3.h"
 
BEGIN_SQ3_C_DECLS
 
/* MARK_C ################################################################ */
 
__parser__(const,class-overload=MkObjectLog)
SQ3_EXTERN void MK_DECL Sq3LiteLog_RT (
  MK_PARSER_RT
  SQ3_LITEN const lite      ,
  MK_PARSER_fmtobj          ,
  MK_DBG  const  debug      __parser__(default=0),
  MK_STRN const  callfunc   __parser__(default=F#FUNC),
  MK_I32  const  lvl        __parser__(default=0)
) MK_ATTR_RT_INSTANCE ;
 
/*****************************************************************************/
/*                                                                           */
/*                            inline functions                               */
/*                                                                           */
/*****************************************************************************/
 
// =========================================================================
// BEGIN-Sq3LiteC-fupu - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Config,om_
 
    #define Sq3Fupu_Sq3LiteBusyHandler_arg1_ret  MK_I32
    #define Sq3Fupu_Sq3LiteBusyHandler_arg1_args MK_PTR arg0, MK_I32 arg1
    typedef Sq3Fupu_Sq3LiteBusyHandler_arg1_ret (*Sq3Fupu_Sq3LiteBusyHandler_arg1) (Sq3Fupu_Sq3LiteBusyHandler_arg1_args);
 
    #define Sq3Fupu_Sq3LiteCommitHook_arg1_ret  MK_I32
    #define Sq3Fupu_Sq3LiteCommitHook_arg1_args MK_PTR arg0
    typedef Sq3Fupu_Sq3LiteCommitHook_arg1_ret (*Sq3Fupu_Sq3LiteCommitHook_arg1) (Sq3Fupu_Sq3LiteCommitHook_arg1_args);
 
    #define Sq3Fupu_Sq3LiteRollbackHook_arg1_ret  void
    #define Sq3Fupu_Sq3LiteRollbackHook_arg1_args MK_PTR arg0
    typedef Sq3Fupu_Sq3LiteRollbackHook_arg1_ret (*Sq3Fupu_Sq3LiteRollbackHook_arg1) (Sq3Fupu_Sq3LiteRollbackHook_arg1_args);
 
    #define Sq3Fupu_Sq3LiteUpdateHook_arg1_ret  void
    #define Sq3Fupu_Sq3LiteUpdateHook_arg1_args MK_PTR arg0, MK_I32 arg1, MK_STRN arg2, MK_STRN arg3, sqlite3_int64 arg4
    typedef Sq3Fupu_Sq3LiteUpdateHook_arg1_ret (*Sq3Fupu_Sq3LiteUpdateHook_arg1) (Sq3Fupu_Sq3LiteUpdateHook_arg1_args);
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Execution,om_
 
    #define Sq3Fupu_Sq3LiteExec_callback_call_ret  MK_I32
    #define Sq3Fupu_Sq3LiteExec_callback_call_args MK_CBP callV1, MK_I32 num, MK_STR *vals, MK_STR *cols
    typedef Sq3Fupu_Sq3LiteExec_callback_call_ret (*Sq3Fupu_Sq3LiteExec_callback_call) (Sq3Fupu_Sq3LiteExec_callback_call_args);
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Misc,om_
 
    #define Sq3Fupu_Sq3LiteAutovacuumPages_arg1_ret  MK_U32
    #define Sq3Fupu_Sq3LiteAutovacuumPages_arg1_args MK_PTR arg0, MK_STRN arg1, MK_U32 arg2, MK_U32 arg3, MK_U32 arg4
    typedef Sq3Fupu_Sq3LiteAutovacuumPages_arg1_ret (*Sq3Fupu_Sq3LiteAutovacuumPages_arg1) (Sq3Fupu_Sq3LiteAutovacuumPages_arg1_args);
 
    #define Sq3Fupu_Sq3LiteAutovacuumPages_arg3_ret  void
    #define Sq3Fupu_Sq3LiteAutovacuumPages_arg3_args MK_PTR arg0
    typedef Sq3Fupu_Sq3LiteAutovacuumPages_arg3_ret (*Sq3Fupu_Sq3LiteAutovacuumPages_arg3) (Sq3Fupu_Sq3LiteAutovacuumPages_arg3_args);
 
    #define Sq3Fupu_Sq3LiteCreateCollation_xCompare_ret  MK_I32
    #define Sq3Fupu_Sq3LiteCreateCollation_xCompare_args MK_PTR arg0, MK_I32 arg1, MK_PTRN arg2, MK_I32 arg3, MK_PTRN arg4
    typedef Sq3Fupu_Sq3LiteCreateCollation_xCompare_ret (*Sq3Fupu_Sq3LiteCreateCollation_xCompare) (Sq3Fupu_Sq3LiteCreateCollation_xCompare_args);
#endif
 
// END-Sq3LiteC-fupu - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// =========================================================================
// BEGIN-Sq3LiteC-inline - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Config,om_
 
  mk_inline enum MkErrorE Sq3LiteBusyHandler (SQ3_LITE sq3lite, Sq3Fupu_Sq3LiteBusyHandler_arg1 arg1, MK_PTR arg2) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_busy_handler(sq3lite->nat, arg1, (MK_PTR)(arg2));
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteBusyTimeout (SQ3_LITE sq3lite, MK_I32 ms) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_busy_timeout(sq3lite->nat, ms);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline MK_PTR Sq3LiteCommitHook (SQ3_LITE sq3lite, Sq3Fupu_Sq3LiteCommitHook_arg1 arg1, MK_PTR arg2) {
    SQ3_INSTANCE_HDL(sq3lite);
    return (MK_PTR)sqlite3_commit_hook(sq3lite->nat, arg1, (MK_PTR)(arg2));
  }
 
  mk_inline enum MkErrorE Sq3LiteDeclareVtab (SQ3_LITE sq3lite, MK_STRN zSQL) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_declare_vtab(sq3lite->nat, zSQL);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteExtendedResultCodes (SQ3_LITE sq3lite, MK_I32 onoff) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_extended_result_codes(sq3lite->nat, onoff);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteLimit (SQ3_LITE sq3lite, enum Sq3LimitE id, MK_I32 newVal) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_limit(sq3lite->nat, id, newVal);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline MK_PTR Sq3LiteRollbackHook (SQ3_LITE sq3lite, Sq3Fupu_Sq3LiteRollbackHook_arg1 arg1, MK_PTR arg2) {
    SQ3_INSTANCE_HDL(sq3lite);
    return (MK_PTR)sqlite3_rollback_hook(sq3lite->nat, arg1, (MK_PTR)(arg2));
  }
 
  mk_inline MK_PTR Sq3LiteUpdateHook (SQ3_LITE sq3lite, Sq3Fupu_Sq3LiteUpdateHook_arg1 arg1, MK_PTR arg2) {
    SQ3_INSTANCE_HDL(sq3lite);
    return (MK_PTR)sqlite3_update_hook(sq3lite->nat, arg1, (MK_PTR)(arg2));
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Error,om_
 
  mk_inline enum Sq3ErrorE Sq3LiteErrCode (SQ3_LITE db) {
    SQ3_INSTANCE_HDL(db);
    return (enum Sq3ErrorE)sqlite3_errcode(db->nat);
  }
 
  mk_inline MK_STRN Sq3LiteErrMsg (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    MK_STRN __retVal__L = sqlite3_errmsg(sq3lite->nat);
    return __retVal__L;
  }
 
  mk_inline enum MkErrorE Sq3LiteErrorOffset (SQ3_LITE db) {
    SQ3_INSTANCE_HDL(db);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_error_offset(db->nat);
    Sq3ErrorE_Check(db, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum Sq3ExtendetResultCodesE Sq3LiteExtendetErrCode (SQ3_LITE db) {
    SQ3_INSTANCE_HDL(db);
    return (enum Sq3ExtendetResultCodesE)sqlite3_extended_errcode(db->nat);
  }
 
  mk_inline enum MkErrorE Sq3LiteSystemErrno (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_system_errno(sq3lite->nat);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Error,sm_
 
  mk_inline MK_STRN Sq3LiteErrStr (MK_I32 arg0) {
    MK_STRN __retVal__L = sqlite3_errstr(arg0);
    return __retVal__L;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Execution,om_
 
  mk_inline enum MkErrorE Sq3LiteExec (SQ3_LITE sq3lite, MK_STRN sql, Sq3Fupu_Sq3LiteExec_callback_call callback_call, MK_CBP callback_data) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_exec(sq3lite->nat, sql, callback_call, callback_data, NULL);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Execution,sm_
 
  mk_inline enum MkErrorE Sq3LiteSleep (MK_I32 arg0) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_sleep(arg0);
    Sq3ErrorE_Check_Static(Sq3LiteC_TT,errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Info,om_
 
  mk_inline MK_I32 Sq3LiteGetAutocommit (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    return sqlite3_get_autocommit(sq3lite->nat);
  }
 
  mk_inline MK_I64 Sq3LiteLastInsertRowid (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    return sqlite3_last_insert_rowid(sq3lite->nat);
  }
 
  mk_inline enum MkErrorE Sq3LiteTxnState (SQ3_LITE sq3lite, MK_STRN zSchema) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_txn_state(sq3lite->nat, zSchema);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteVtabOnConflict (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_vtab_on_conflict(sq3lite->nat);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Misc,om_
 
  mk_inline enum MkErrorE Sq3LiteAutovacuumPages (SQ3_LITE db, Sq3Fupu_Sq3LiteAutovacuumPages_arg1 arg1, MK_PTR arg2, Sq3Fupu_Sq3LiteAutovacuumPages_arg3 arg3) {
    SQ3_INSTANCE_HDL(db);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_autovacuum_pages(db->nat, arg1, (MK_PTR)(arg2), arg3);
    Sq3ErrorE_Check(db, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteCreateCollation (SQ3_LITE sq3lite, MK_STRN zName, MK_I32 eTextRep, MK_PTR pArg, Sq3Fupu_Sq3LiteCreateCollation_xCompare xCompare) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_create_collation(sq3lite->nat, zName, eTextRep, (MK_PTR)(pArg), xCompare);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteDbCacheflush (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_db_cacheflush(sq3lite->nat);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline SQ3_FILENAME Sq3LiteDbFilename (SQ3_LITE db, MK_STRN zDbName) {
    SQ3_INSTANCE_HDL(db);
    SQ3_FILENAME __retVal__L = sqlite3_db_filename(db->nat, zDbName);
    return __retVal__L;
  }
 
  mk_inline MK_STRN Sq3LiteDbName (SQ3_LITE db, MK_I32 N) {
    SQ3_INSTANCE_HDL(db);
    MK_STRN __retVal__L = sqlite3_db_name(db->nat, N);
    return __retVal__L;
  }
 
  mk_inline enum MkErrorE Sq3LiteDbReadonly (SQ3_LITE db, MK_STRN zDbName) {
    SQ3_INSTANCE_HDL(db);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_db_readonly(db->nat, zDbName);
    Sq3ErrorE_Check(db, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteDbReleaseMemory (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_db_release_memory(sq3lite->nat);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteDeserializeHide (SQ3_LITE db, MK_STRN zSchema, MK_BIN pData, MK_I64 szDb, MK_I64 szBuf, enum Sq3DeSerializeEF mFlags) {
    SQ3_INSTANCE_HDL(db);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_deserialize(db->nat, zSchema, pData, szDb, szBuf, mFlags);
    Sq3ErrorE_Check(db, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteDropModulesHide (SQ3_LITE db, MK_STRN *azKeep) {
    SQ3_INSTANCE_HDL(db);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_drop_modules(db->nat, azKeep);
    Sq3ErrorE_Check(db, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteFileControl (SQ3_LITE sq3lite, MK_STRN zDbName, enum Sq3TestCtrlE op, MK_PTR arg3) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_file_control(sq3lite->nat, zDbName, op, (MK_PTR)(arg3));
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3LiteOverloadFunction (SQ3_LITE sq3lite, MK_STRN zFuncName, MK_I32 nArg) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_overload_function(sq3lite->nat, zFuncName, nArg);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Misc,omo
 
  mk_inline enum MkErrorE Sq3LiteDbStatus (SQ3_LITE sq3lite, enum Sq3DbStatusE op, MK_I32 *pCur, MK_I32 *pHiwtr, MK_BOOL resetFlg) {
    SQ3_INSTANCE_HDL(sq3lite);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_db_status(sq3lite->nat, op, pCur, pHiwtr, resetFlg);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline MK_BIN Sq3LiteSerializeHide (SQ3_LITE db, MK_STRN zSchema, MK_I64 *piSize, enum Sq3SerializeE mFlags) {
    SQ3_INSTANCE_HDL(db);
    return sqlite3_serialize(db->nat, zSchema, piSize, mFlags);
  }
 
  mk_inline enum MkErrorE Sq3LiteTableColumnMetadata (SQ3_LITE db, MK_STRN zDbName, MK_STRN zTableName, MK_STRN zColumnName, MK_STRN *pzDataType, MK_STRN *pzCollSeq, MK_I32 *pNotNull, MK_I32 *pPrimaryKey, MK_I32 *pAutoinc) {
    SQ3_INSTANCE_HDL(db);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_table_column_metadata(db->nat, zDbName, zTableName, zColumnName, pzDataType, pzCollSeq, pNotNull, pPrimaryKey, pAutoinc);
    Sq3ErrorE_Check(db, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,om_
 
  mk_inline enum MkErrorE Sq3LiteWalAutocheckpoint (SQ3_LITE db, MK_I32 N) {
    SQ3_INSTANCE_HDL(db);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_wal_autocheckpoint(db->nat, N);
    Sq3ErrorE_Check(db, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,omo
 
  mk_inline enum MkErrorE Sq3LiteWalCheckpointV2 (SQ3_LITE db, MK_STRN zDb, MK_I32 eMode, MK_I32 *pnLog, MK_I32 *pnCkpt) {
    SQ3_INSTANCE_HDL(db);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_wal_checkpoint_v2(db->nat, zDb, eMode, pnLog, pnCkpt);
    Sq3ErrorE_Check(db, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Query,om_
 
  mk_inline void Sq3LiteInterrupt (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    sqlite3_interrupt(sq3lite->nat);
  }
 
  mk_inline MK_BOOL Sq3LiteIsInterrupted (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    return (MK_BOOL)sqlite3_is_interrupted(sq3lite->nat);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-Row,om_
 
  mk_inline MK_I32 Sq3LiteChanges (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    return sqlite3_changes(sq3lite->nat);
  }
 
  mk_inline MK_I64 Sq3LiteChanges64 (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    return sqlite3_changes64(sq3lite->nat);
  }
 
  mk_inline void Sq3LiteSetLastInsertRowid (SQ3_LITE sq3lite, MK_I64 arg1) {
    SQ3_INSTANCE_HDL(sq3lite);
    sqlite3_set_last_insert_rowid(sq3lite->nat, arg1);
  }
 
  mk_inline MK_I32 Sq3LiteTotalChanges (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    return sqlite3_total_changes(sq3lite->nat);
  }
 
  mk_inline MK_I64 Sq3LiteTotalChanges64 (SQ3_LITE sq3lite) {
    SQ3_INSTANCE_HDL(sq3lite);
    return sqlite3_total_changes64(sq3lite->nat);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3LiteC,Sq3LiteC-TOR,sCo
 
  mk_inline enum MkErrorE Sq3LiteOpenV2 (MK_STRN filename, SQ3_LITE *ppDb, enum Sq3OpenEF flags, MK_STRN zVfs) {
    *ppDb = NULL;
    sqlite3* ppDb_val = NULL;
    if (MK_NULL_STR_CHECK_1(zVfs)) zVfs = NULL;
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_open_v2(filename, &ppDb_val, flags, zVfs);
    *ppDb = Sq3LiteC_ObjCreate(ppDb_val);
    Sq3ErrorE_Check_Static(Sq3LiteC_TT,errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  // doc-key: Sq3LiteC,Sq3LiteC-TOR,om_
 
  mk_inline enum MkErrorE Sq3LiteCloseV2 (SQ3_LITE sq3lite) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_close_v2(sq3lite->nat);
    Sq3ErrorE_Check(sq3lite, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
// END-Sq3LiteC-inline - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// =============================================================================================
// OVERLOAD
//
 
MK_ATTR_INSTANCE
mk_inline MkBinaryR Sq3LiteSerialize (SQ3_LITE sq3lite, MK_STRN zSchema, enum Sq3SerializeE mFlags) {
  SQ3_INSTANCE_HDL(sq3lite);
 
  MK_I64 piSize_val = 0;
  MK_BIN __retVal__L = Sq3LiteSerializeHide(sq3lite, zSchema, &piSize_val, mFlags);
  return MkBinaryCreate((MK_SIZE)piSize_val,__retVal__L);
} 
 
MK_ATTR_RT_INSTANCE
mk_inline enum MkErrorE Sq3LiteDeserialize_RT (
  MK_PARSER_RT
  SQ3_LITE sq3lite, 
  MK_STRN zSchema, 
  MkBinaryR pData, 
  enum Sq3DeSerializeEF mFlags
) {
  SQ3_INSTANCE_RT_X(sq3lite);
 
  Sq3LiteDeserializeHide_E(sq3lite, zSchema, (MK_BIN)pData.data, (MK_I64)pData.size, (MK_I64)pData.size, mFlags);
  return MK_OK;
error:
  return MkErrorStack_1X(sq3lite);
} 
 
enum MkErrorE Sq3LiteVtabConfig (SQ3_LITE sq3lite, Sq3VtabE op, ...);
#define Sq3LiteVtabConfig(sq3lite, op, ...) ({                              \
  Sq3ErrorE errVal = sqlite3_vtab_config(sq3lite->nat, op, __VA_ARGS__);    \
  Sq3ErrorE_Check_Macro(sq3lite,errVal);                                    \
  if (unlikely(Sq3ErrorCheckI(errVal))) {                                   \
    Sq3LiteErrorToMQ(MkOBJ(sq3lite), __func__,__FILE__,__LINE__);           \
    MK_ERROR;                                                               \
  } else {                                                                  \
    MK_OK;                                                                  \
  }                                                                         \
})
 
MK_ATTR_RT_INSTANCE
mk_inline enum MkErrorE Sq3LiteDbStatusBFL_RT (
  MK_PARSER_RT 
  SQ3_LITE            sq3lite, 
  enum Sq3DbStatusE   op, 
  MK_BFL              *val_out, 
  MK_BOOL             resetFlg
) {
  assert(val_out != NULL);
  SQ3_INSTANCE_RT_X(sq3lite);
 
  MkBufferListCreateTLS_T(bfl,2);
  MK_I32  pCur;
  MK_I32  pHiwtr;
  Sq3LiteDbStatus_E(sq3lite,op,&pCur,&pHiwtr,resetFlg);
  MkBufferListAppendI32(bfl,pCur);
  MkBufferListAppendI32(bfl,pHiwtr);
  *val_out = bfl;
  MkErrorReturnLabel(sq3lite);
} 
 
SQ3_EXTERN enum MkErrorE MK_DECL Sq3LiteDropModules_RT (
  MK_PARSER_RT
  SQ3_LITE sq3lite, 
  MK_BFL azKeepBfl
) MK_ATTR_RT_INSTANCE ;
 
// this is the sqlite3_prepare_v2 but as "Sq3LiteC" method
__parser__(class=Sq3LiteC,constructor)
MK_ATTR_INSTANCE
mk_inline enum MkErrorE Sq3LitePrepareV2 ( 
  SQ3_LITE  db, 
  MkStringR zSql, 
  SQ3_STMT  *ppStmt   __parser__(out)
) {
  SQ3_INSTANCE_HDL(db);
  MkRtSetup_X(db);
  MK_STRN pzTail = NULL;
  MkErrorE_Check(Sq3StmtPrepareV2Hide(db,zSql.ptr,zSql.len,ppStmt,&pzTail));
  (*ppStmt)->pzTail = pzTail;
  MkErrorReturnLabel(db);
} 
 
// ---------------------------------------------------------------------------------------------------
 
 
#define Sq3Fupu_Sq3LiteExec_callback_call_check do { \
  assert(callV1 != NULL); \
} while (0)
 
#define Sq3Fupu_Sq3LiteExecV2CB_callback_call_check do { \
  assert(callV2 != NULL); \
} while (0)
 
// doc-key: Sq3LiteC,Sq3LiteC-Execution,om_
#define Sq3LiteExecV2CB_ret   enum MkErrorE
#define Sq3LiteExecV2CB_args  MK_RT_ARGS MK_CBP callV2, MK_BFL vals, MK_BFL cols
 
typedef enum MkErrorE (*Sq3LiteExecV2CB) (MK_RT_ARGS MK_CBP callV2, MK_BFL vals, MK_BFL cols);
 
__parser__(class=Sq3LiteC,doc-group=Execution,callback-name=LiteExecV2,callback-null,callback-once)
SQ3_EXTERN enum MkErrorE Sq3LiteExecV2_RT (
  MK_PARSER_RT
  SQ3_LITE        sq3lite, 
  MK_STRN         sql, 
  Sq3LiteExecV2CB callback_call __parser__(callback-call),
  MK_CBP          callback      __parser__(callback-data)
) MK_ATTR_RT_INSTANCE ;
 
// Sq3LiteC_Execution_C_API
 
END_SQ3_C_DECLS