Sq3LiteC_cc.hh

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#pragma once
 
#include <list>
#include <vector>
 
// [Sq3LiteExecIF]
namespace ccsq3lite {
 
  class Sq3LiteExecIF {
    public:
      virtual void callback (const std::vector<std::string>& vals, const std::vector<std::string>& cols) = 0;
  };
}
// [Sq3LiteExecIF]
 
// [Sq3LiteExecSCB]
namespace ccsq3lite {
  typedef void  (*Sq3LiteExecSCB) (const std::vector<std::string>& vals, const std::vector<std::string>& cols);
}
// [Sq3LiteExecSCB]
 
// [Sq3LiteExecV2IF]
namespace ccsq3lite {
 
  class Sq3LiteExecV2IF {
    public:
      virtual void callback (const MkBufferListC& valL, const MkBufferListC& colL) = 0;
  };
}
// [Sq3LiteExecV2IF]
 
// [Sq3LiteExecV2SCB]
namespace ccsq3lite {
  typedef void  (*Sq3LiteExecV2SCB) (const MkBufferListC& vals, const MkBufferListC& cols);
}
// [Sq3LiteExecV2SCB]
 
namespace ccsq3lite {
 
  typedef struct {
    MK_NUM    size;
    Sq3LiteC **data;
  } Sq3LiteC_A;
 
  class Sq3LiteC : public MkObjectC {
 
    friend class Sq3Lite;
    friend class Sq3LiteExecCallbackC;
 
    static inline MK_PTR Sq3LiteC_selfCreateTLS (MK_OBJ obj);
 
/* LABEL-START */
 
 
    public:
      static thread_local Sq3LiteC MK_NULL_REF;
 
    private:
 
      static Sq3LiteC* Sq3LiteC_GetSelf (SQ3_LITE hdl) {
        return (hdl != NULL ? static_cast<Sq3LiteC*>((*Sq3LiteC_X2obj(hdl)).self) : &MK_NULL_REF);
      }
 
    #ifdef Sq3LiteC_selfCreate_overload
      static MK_PTR Sq3LiteC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env);
    #else
      static MK_PTR Sq3LiteC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
        return new Sq3LiteC(obj);
      }
    #endif
 
      static void Sq3LiteC_selfDelete (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        delete static_cast<Sq3LiteC*>(self);
      }
 
      static void Sq3LiteC_selfUnlink (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        Sq3LiteC* selfO = static_cast<Sq3LiteC*>(self);
        selfO->atomUnlink();
      }
 
      void Sq3LiteC_Init (SQ3_LITE hdl)   { atomInit(Sq3LiteC_X2obj(hdl)); };
 
 
      static Sq3LiteC* Sq3LiteC_ObjCreate (MK_RT_ARGS SQ3_LITE hdl) {
        return static_cast<Sq3LiteC*>(MkObjectC::atomObjCreate(MK_RT_CALL Sq3LiteC_X2obj(hdl)));
      }
 
#ifndef META_IS_MkObjectC
      Sq3LiteC   (MK_OBJ obj) : MkObjectC(obj) {};
#endif
 
    public:
 
#ifndef META_IS_MkObjectC
      Sq3LiteC   (SQ3_LITE hdl) : MkObjectC(Sq3LiteC_X2obj(hdl)) {};
#endif
 
      static Sq3LiteC* Sq3LiteC_ObjNew (MK_RT_ARGS SQ3_LITE hdl) {
        return (hdl ? static_cast<Sq3LiteC*>(MkObjectC::atomObjNew(MK_RT_CALL Sq3LiteC_X2obj(hdl))) : &MK_NULL_REF);
      }
 
      SQ3_LITE getLITE() const {
        SQ3_LITE ret = reinterpret_cast<SQ3_LITE>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      SQ3_LITE getLITE__null_allow() const {
        return reinterpret_cast<SQ3_LITE>(hdl);
      };
 
      SQ3_LITEN getLITEN() const {
        SQ3_LITEN ret = reinterpret_cast<SQ3_LITEN>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      SQ3_LITEN getLITEN__null_allow() const {
        return reinterpret_cast<SQ3_LITEN>(hdl);
      };
 
      static SQ3_LITE getLITE(Sq3LiteC* clsHdl) {
        SQ3_LITE ret = clsHdl ? reinterpret_cast<SQ3_LITE>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(Sq3LiteC);
        return ret;
      };
 
      static SQ3_LITE getLITE__null_allow(Sq3LiteC* clsHdl) {
        return clsHdl ? reinterpret_cast<SQ3_LITE>(clsHdl->hdl) : NULL;
      };
 
      static SQ3_LITEN getLITEN(const Sq3LiteC* clsHdl) {
        SQ3_LITEN ret = clsHdl ? reinterpret_cast<SQ3_LITEN>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(Sq3LiteC);
        return ret;
      };
 
      static SQ3_LITEN getLITEN__null_allow(const Sq3LiteC* clsHdl) {
        return clsHdl ? reinterpret_cast<SQ3_LITEN>(clsHdl->hdl) : NULL;
      };
 
      static SQ3_LITE getLITE(const Sq3LiteC& clsHdl) {
        return clsHdl.getLITE();
      };
 
      static SQ3_LITE getLITE__null_allow(const Sq3LiteC& clsHdl) {
        return clsHdl.getLITE__null_allow();
      };
 
      static SQ3_LITEN getLITEN(const Sq3LiteC& clsHdl) {
        return clsHdl.getLITEN();
      };
 
      static SQ3_LITEN getLITEN__null_allow(const Sq3LiteC& clsHdl) {
        return clsHdl.getLITEN__null_allow();
      };
 
      bool Check() const {
        return (hdl && Sq3LiteCheck(hdl));
      };
 
/* LABEL-END */
 
    public:
 
/* no COPY constructor
      Sq3LiteC   (const Sq3LiteC* hdl);
      Sq3LiteC   (const Sq3LiteC& ref);
      Sq3LiteC&  operator= (const Sq3LiteC& buf);
      Sq3LiteC&  operator= (const Sq3LiteC* buf);
*/
 
    //   BEGIN-Sq3LiteC - created by 'cc_MqS.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Class-Export,sc_,public
 
      static Sq3LiteC* HandleResolve (MK_HDL netHdl);
 
      // doc-key: Sq3LiteC,Sq3LiteC-Class-Export,om_,public
 
      // skip class-overload: MK_HDL HandleGet ()
 
    // Sq3LiteC_Class_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Class-Introspection,oc_,public
 
      Sq3LiteC* Next ();
 
      Sq3LiteC* Prev ();
 
      // doc-key: Sq3LiteC,Sq3LiteC-Class-Introspection,sc_,public
 
      static Sq3LiteC* Instances ();
 
    // Sq3LiteC_Class_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Class-Misc,sc_,public
 
      static Sq3LiteC* GetNull ();
 
    // Sq3LiteC_Class_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Config,om_,public
 
      void BusyTimeout (MK_I32 ms);
 
      void DeclareVtab (MK_STRN zSQL);
 
      void DeclareVtab (const std::string& zSQL);
 
      void ExtendedResultCodes (MK_I32 onoff);
 
      void Limit (Sq3LimitE id, MK_I32 newVal);
 
    // Sq3LiteC_Config_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Error,om_,public
 
      Sq3ErrorE ErrCode ();
 
      MK_STRN ErrMsg ();
 
      void ErrorOffset ();
 
      Sq3ExtendetResultCodesE ExtendetErrCode ();
 
      void SystemErrno ();
 
      // doc-key: Sq3LiteC,Sq3LiteC-Error,sm_,public
 
      static MK_STRN ErrStr (MK_I32 arg0);
 
    // Sq3LiteC_Error_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Execution,om_,public
 
      void ExecV2 (MK_STRN sql, Sq3LiteExecV2IF* callback = NULL);
 
      void ExecV2 (const std::string& sql, Sq3LiteExecV2IF* callback = NULL);
 
      void ExecV2 (MK_STRN sql, Sq3LiteExecV2SCB callback = NULL);
 
      void ExecV2 (const std::string& sql, Sq3LiteExecV2SCB callback = NULL);
 
      void Exec (MK_STRN sql, Sq3LiteExecIF* callback_data = NULL);
 
      void Exec (const std::string& sql, Sq3LiteExecIF* callback_data = NULL);
 
      void Exec (MK_STRN sql, Sq3LiteExecSCB callback_data = NULL);
 
      void Exec (const std::string& sql, Sq3LiteExecSCB callback_data = NULL);
 
      // doc-key: Sq3LiteC,Sq3LiteC-Execution,sm_,public
 
      static void Sleep (MK_I32 arg0);
 
    // Sq3LiteC_Execution_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Info,om_,public
 
      MK_I32 GetAutocommit ();
 
      MK_I64 LastInsertRowid ();
 
      void TxnState (MK_STRN zSchema);
 
      void TxnState (const std::string& zSchema);
 
      void VtabOnConflict ();
 
    // Sq3LiteC_Info_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Misc,oco,public
 
      MkBufferListC* DbStatusBFL (Sq3DbStatusE op, MK_BOOL resetFlg);
 
      // doc-key: Sq3LiteC,Sq3LiteC-Misc,om_,public
 
      void DbCacheflush ();
 
      SQ3_FILENAME DbFilename (MK_STRN zDbName);
 
      SQ3_FILENAME DbFilename (const std::string& zDbName);
 
      MK_STRN DbName (MK_I32 N);
 
      void DbReadonly (MK_STRN zDbName);
 
      void DbReadonly (const std::string& zDbName);
 
      void DbReleaseMemory ();
 
      void Deserialize (MK_STRN zSchema, MK_BNP pData, Sq3DeSerializeEF mFlags);
 
      void Deserialize (const std::string& zSchema, MK_BNP pData, Sq3DeSerializeEF mFlags);
 
      void DropModules (MkBufferListC* azKeepBfl);
 
      void DropModules (const MkBufferListC& azKeepBfl);
 
      // skip class-overload: void Log (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const
 
      // skip class-overload: void Log (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const
 
      void OverloadFunction (MK_STRN zFuncName, MK_I32 nArg);
 
      void OverloadFunction (const std::string& zFuncName, MK_I32 nArg);
 
      MK_BNP Serialize (MK_STRN zSchema, Sq3SerializeE mFlags);
 
      MK_BNP Serialize (const std::string& zSchema, Sq3SerializeE mFlags);
 
      // doc-key: Sq3LiteC,Sq3LiteC-Misc,omo,public
 
      std::tuple<MK_I32,MK_I32> DbStatus (Sq3DbStatusE op, MK_BOOL resetFlg);
 
      std::tuple<MK_STRN,MK_STRN,MK_I32,MK_I32,MK_I32> TableColumnMetadata (MK_STRN zDbName, MK_STRN zTableName, MK_STRN zColumnName);
 
      std::tuple<MK_STRN,MK_STRN,MK_I32,MK_I32,MK_I32> TableColumnMetadata (const std::string& zDbName, const std::string& zTableName, const std::string& zColumnName);
 
    // Sq3LiteC_Misc_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,om_,public
 
      void WalAutocheckpoint (MK_I32 N);
 
      // doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,omo,public
 
      std::tuple<MK_I32,MK_I32> WalCheckpointV2 (MK_STRN zDb, MK_I32 eMode);
 
      std::tuple<MK_I32,MK_I32> WalCheckpointV2 (const std::string& zDb, MK_I32 eMode);
 
    // Sq3LiteC_Modify_Wal_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Query,om_,public
 
      void Interrupt ();
 
      MK_BOOL IsInterrupted ();
 
    // Sq3LiteC_Query_CC_API
 
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-Row,om_,public
 
      MK_I32 Changes ();
 
      MK_I64 Changes64 ();
 
      void SetLastInsertRowid (MK_I64 arg1);
 
      MK_I32 TotalChanges ();
 
      MK_I64 TotalChanges64 ();
 
    // Sq3LiteC_Row_CC_API
 
 
    private:
 
      // doc-key: Sq3LiteC,Sq3LiteC-TOR,sCo,private
 
      static MK_OBJ CTOR (MK_STRN filename, Sq3OpenEF flags = SQ3_OPEN_READWRITE|SQ3_OPEN_CREATE, MK_STRN zVfs = NULL);
 
      static MK_OBJ CTOR (const std::string& filename, Sq3OpenEF flags = SQ3_OPEN_READWRITE|SQ3_OPEN_CREATE, MK_STRN zVfs = NULL);
 
    public:
 
      // doc-key: Sq3LiteC,Sq3LiteC-TOR,sCo,public
 
      static Sq3LiteC* OpenV2 (MK_STRN filename, Sq3OpenEF flags = SQ3_OPEN_READWRITE|SQ3_OPEN_CREATE, MK_STRN zVfs = NULL);
 
      Sq3LiteC (MK_STRN filename, Sq3OpenEF flags = SQ3_OPEN_READWRITE|SQ3_OPEN_CREATE, MK_STRN zVfs = NULL) : MkObjectC(CTOR(filename, flags, zVfs)) {};
 
      static Sq3LiteC* OpenV2 (const std::string& filename, Sq3OpenEF flags = SQ3_OPEN_READWRITE|SQ3_OPEN_CREATE, MK_STRN zVfs = NULL);
 
      Sq3LiteC (const std::string& filename, Sq3OpenEF flags = SQ3_OPEN_READWRITE|SQ3_OPEN_CREATE, MK_STRN zVfs = NULL) : MkObjectC(CTOR(filename, flags, zVfs)) {};
 
      // doc-key: Sq3LiteC,Sq3LiteC-TOR,oco,public
 
      Sq3StmtC* PrepareV2 (const std::string& zSql);
 
      // doc-key: Sq3LiteC,Sq3LiteC-TOR,om_,public
 
      void CloseV2 ();
 
    // Sq3LiteC_TOR_CC_API
 
    //   END-Sq3LiteC - created by 'cc_MqS.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
 
  };    // class Sq3LiteC
}   // namespace ccsq3lite