Sq3StmtC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
#pragma once
 
namespace ccsq3lite {
 
/*
  inline MK_PTR Sq3StmtC::Sq3StmtC_selfCreateTLS(MK_OBJ obj) {
    return new Sq3StmtC(obj);
  }
 
  inline MK_PTR Sq3StmtC::Sq3StmtC_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 ? Sq3StmtC_selfCreateTLS(obj) : new Sq3StmtC(obj);
  }
*/
 
  //   BEGIN-Sq3StmtC - created by 'cc_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-Bind,om_
 
  inline void Sq3StmtC::BindBlob (MK_I32 pos, MK_BNP blob)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    const MkBinaryR blob_ref = MkBinaryCreate(blob.first,blob.second);
    enum MkErrorE errVal = Sq3StmtBindBlob(sq3stmt, pos, blob_ref);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindDouble (MK_I32 arg1, MK_DBL arg2)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBindDouble(sq3stmt, arg1, arg2);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindInt (MK_I32 arg1, MK_I32 arg2)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBindInt(sq3stmt, arg1, arg2);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindInt64 (MK_I32 arg1, MK_I64 arg2)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBindInt64(sq3stmt, arg1, arg2);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindNull (MK_I32 arg1)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBindNull(sq3stmt, arg1);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindParameterCount ()  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBindParameterCount(sq3stmt);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindParameterIndex (MK_STRN zName)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBindParameterIndex(sq3stmt, zName);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindParameterIndex (const std::string& zName)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    const MK_STRN zName_hdl = zName.c_str();
    enum MkErrorE errVal = Sq3StmtBindParameterIndex(sq3stmt, zName_hdl);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline MK_STRN Sq3StmtC::BindParameterName (MK_I32 arg1)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MK_STRN __retVal__L = Sq3StmtBindParameterName(sq3stmt, arg1);
    return __retVal__L;
  }
 
  inline void Sq3StmtC::BindText (MK_I32 pos, const std::string& text)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    const MkStringR text_ref = MkStringCreate((MK_NUM)text.size(),text.c_str());
    enum MkErrorE errVal = Sq3StmtBindText(sq3stmt, pos, text_ref);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindValue (MK_I32 arg1, const Sq3ValueC* arg2)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    SQ3_VALN arg2_hdl = Sq3ValueC::getVALN(arg2);
    enum MkErrorE errVal = Sq3StmtBindValue(sq3stmt, arg1, arg2_hdl);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindValue (MK_I32 arg1, const Sq3ValueC& arg2)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    const SQ3_VALN arg2_hdl = Sq3ValueC::getVALN(arg2);
    enum MkErrorE errVal = Sq3StmtBindValue(sq3stmt, arg1, arg2_hdl);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindZeroblob (MK_I32 arg1, MK_I32 n)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBindZeroblob(sq3stmt, arg1, n);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::BindZeroblob64 (MK_I32 arg1, MK_I64 arg2)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBindZeroblob64(sq3stmt, arg1, arg2);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  // Sq3StmtC_Bind_CC_API
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-Class-Export,sc_
 
  inline Sq3StmtC* Sq3StmtC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    SQ3_STMT __retVal__L = Sq3StmtHandleResolve(netHdl);
    return Sq3StmtC::Sq3StmtC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Class-Export,om_
 
  // skip class-overload: HandleGet = Sq3StmtHandleGet → MkObjectHandleGet
 
  // Sq3StmtC_Class_CC_API
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-Class-Introspection,oc_
 
  inline Sq3StmtC* Sq3StmtC::Next ()  {
    MK_UNUSED auto stmt = getSTMT();
    SQ3_STMT __retVal__L = Sq3StmtNext(stmt);
    return Sq3StmtC::Sq3StmtC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline Sq3StmtC* Sq3StmtC::Prev ()  {
    MK_UNUSED auto stmt = getSTMT();
    SQ3_STMT __retVal__L = Sq3StmtPrev(stmt);
    return Sq3StmtC::Sq3StmtC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Class-Introspection,sc_
 
  inline Sq3StmtC* Sq3StmtC::Instances ()  {
    MkRtSetup_NULL;
    SQ3_STMT __retVal__L = Sq3StmtInstances();
    return Sq3StmtC::Sq3StmtC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // Sq3StmtC_Class_CC_API
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-Class-Misc,sc_
 
  inline Sq3StmtC* Sq3StmtC::GetNull ()  {
    MkRtSetup_NULL;
    SQ3_STMT __retVal__L = Sq3StmtGetNull();
    return Sq3StmtC::Sq3StmtC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // Sq3StmtC_Class_CC_API
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-Column,oc_
 
  inline Sq3ValueC* Sq3StmtC::ColumnValue (MK_I32 iCol)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    SQ3_VAL __retVal__L = Sq3StmtColumnValue(sq3stmt, iCol);
    return Sq3ValueC::Sq3ValueC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Column,om_
 
  inline MK_BNP Sq3StmtC::ColumnBlob (MK_I32 iCol)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MkBinaryR __retVal__L = Sq3StmtColumnBlob(sq3stmt, iCol);
    return std::make_pair(MkBinaryGetSize(__retVal__L),MkBinaryGetData(__retVal__L));
  }
 
  inline MK_I32 Sq3StmtC::ColumnBytes (MK_I32 iCol)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MK_I32 __retVal__L = Sq3StmtColumnBytes(sq3stmt, iCol);
    return __retVal__L;
  }
 
  inline MK_I32 Sq3StmtC::ColumnCount ()  {
    MK_UNUSED auto pStmt = getSTMT();
    MK_I32 __retVal__L = Sq3StmtColumnCount(pStmt);
    return __retVal__L;
  }
 
  inline MK_DBL Sq3StmtC::ColumnDouble (MK_I32 iCol)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MK_DBL __retVal__L = Sq3StmtColumnDouble(sq3stmt, iCol);
    return __retVal__L;
  }
 
  inline MK_I32 Sq3StmtC::ColumnInt (MK_I32 iCol)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MK_I32 __retVal__L = Sq3StmtColumnInt(sq3stmt, iCol);
    return __retVal__L;
  }
 
  inline MK_I64 Sq3StmtC::ColumnInt64 (MK_I32 iCol)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MK_I64 __retVal__L = Sq3StmtColumnInt64(sq3stmt, iCol);
    return __retVal__L;
  }
 
  inline MK_STRN Sq3StmtC::ColumnName (MK_I32 N)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MK_STRN __retVal__L = Sq3StmtColumnName(sq3stmt, N);
    return __retVal__L;
  }
 
  inline std::string Sq3StmtC::ColumnText (MK_I32 iCol)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MkStringR __retVal__L = Sq3StmtColumnText(sq3stmt, iCol);
    return std::string(MkStringGetData(__retVal__L),MkStringGetSize(__retVal__L));
  }
 
  inline Sq3TypeE Sq3StmtC::ColumnType (MK_I32 iCol)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum Sq3TypeE __retVal__L = Sq3StmtColumnType(sq3stmt, iCol);
    return __retVal__L;
  }
 
  // Sq3StmtC_Column_CC_API
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-Info,oc_
 
  inline Sq3LiteC* Sq3StmtC::DbHandle ()  {
    MK_UNUSED auto sq3stmt = getSTMT();
    SQ3_LITE __retVal__L = Sq3StmtDbHandle(sq3stmt);
    return Sq3LiteC::Sq3LiteC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Info,om_
 
  inline void Sq3StmtC::Busy ()  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtBusy(sq3stmt);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::DataCount ()  {
    MK_UNUSED auto pStmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtDataCount(pStmt);
    MkErrorC_Check(pStmt, errVal);
  }
 
  inline void Sq3StmtC::IsExplain ()  {
    MK_UNUSED auto pStmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtIsExplain(pStmt);
    MkErrorC_Check(pStmt, errVal);
  }
 
  // skip class-overload: Log = Sq3StmtLog → MkObjectLog
 
  // skip class-overload: Log = Sq3StmtLog → MkObjectLog
 
  inline void Sq3StmtC::Readonly ()  {
    MK_UNUSED auto pStmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtReadonly(pStmt);
    MkErrorC_Check(pStmt, errVal);
  }
 
  inline void Sq3StmtC::Status (Sq3StmtStatusE op, MK_BOOL resetFlg)  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtStatus(sq3stmt, op, resetFlg);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  // Sq3StmtC_Info_CC_API
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-Misc,sc_
 
  inline Sq3StmtC* Sq3StmtC::NextStmt (Sq3LiteC* pDb, Sq3StmtC* pStmt)  {
    MkRtSetup_NULL;
    SQ3_LITE pDb_hdl = Sq3LiteC::getLITE(pDb);
    SQ3_STMT pStmt_hdl = Sq3StmtC::getSTMT__null_allow(pStmt);
    SQ3_STMT __retVal__L = Sq3StmtNextStmt(pDb_hdl, pStmt_hdl);
    return Sq3StmtC::Sq3StmtC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline Sq3StmtC* Sq3StmtC::NextStmt (const Sq3LiteC& pDb, const Sq3StmtC& pStmt)  {
    MkRtSetup_NULL;
    const SQ3_LITE pDb_hdl = Sq3LiteC::getLITE(pDb);
    const SQ3_STMT pStmt_hdl = Sq3StmtC::getSTMT(pStmt);
    SQ3_STMT __retVal__L = Sq3StmtNextStmt(pDb_hdl, pStmt_hdl);
    return Sq3StmtC::Sq3StmtC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Misc,om_
 
  inline void Sq3StmtC::ClearBindings ()  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtClearBindings(sq3stmt);
    MkErrorC_Check(sq3stmt, errVal);
  }
 
  inline void Sq3StmtC::Explain (MK_I32 eMode)  {
    MK_UNUSED auto pStmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtExplain(pStmt, eMode);
    MkErrorC_Check(pStmt, errVal);
  }
 
  inline void Sq3StmtC::Reset ()  {
    MK_UNUSED auto pStmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtReset(pStmt);
    MkErrorC_Check(pStmt, errVal);
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Misc,omo
 
  inline Sq3ErrorE Sq3StmtC::Step ()  {
    MK_UNUSED auto sq3stmt = getSTMT();
    enum Sq3ErrorE retCode;
    enum MkErrorE errVal = Sq3StmtStep(sq3stmt, &retCode);
    MkErrorC_Check(sq3stmt, errVal);
    return retCode;
  }
 
  // Sq3StmtC_Misc_CC_API
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-Sql,om_
 
  inline MK_STR Sq3StmtC::ExpandedSql ()  {
    MK_UNUSED auto pStmt = getSTMT();
    MK_STR __retVal__L = Sq3StmtExpandedSql(pStmt);
    return __retVal__L;
  }
 
  inline MK_STRN Sq3StmtC::GetPzTail ()  {
    MK_UNUSED auto sq3stmt = getSTMT();
    MK_STRN __retVal__L = Sq3StmtGetPzTail(sq3stmt);
    return __retVal__L;
  }
 
  inline MK_STRN Sq3StmtC::Sql ()  {
    MK_UNUSED auto pStmt = getSTMT();
    MK_STRN __retVal__L = Sq3StmtSql(pStmt);
    return __retVal__L;
  }
 
  // Sq3StmtC_Sql_CC_API
 
 
  // doc-key: Sq3StmtC,Sq3StmtC-TOR,sCo
 
  inline MK_OBJ Sq3StmtC::CTOR (Sq3LiteC* db, const std::string& zSql)  {
    MkRtSetup_NULL;
    SQ3_STMT ppStmt;
    SQ3_LITE db_hdl = Sq3LiteC::getLITE(db);
    const MkStringR zSql_ref = MkStringCreate((MK_NUM)zSql.size(),zSql.c_str());
    enum MkErrorE errVal = Sq3StmtPrepareV2(db_hdl, zSql_ref, &ppStmt);
    MkErrorC_Check(NULL, errVal);
    return (MK_OBJ)ppStmt;
  }
 
  inline Sq3StmtC* Sq3StmtC::PrepareV2 (Sq3LiteC* db, const std::string& zSql)  {
    MkRtSetup_NULL;
    SQ3_STMT ppStmt;
    SQ3_LITE db_hdl = Sq3LiteC::getLITE(db);
    const MkStringR zSql_ref = MkStringCreate((MK_NUM)zSql.size(),zSql.c_str());
    enum MkErrorE errVal = Sq3StmtPrepareV2(db_hdl, zSql_ref, &ppStmt);
    MkErrorC_Check(NULL, errVal);
    return Sq3StmtC::Sq3StmtC_ObjCreate(MK_RT_CALL ppStmt);
  }
 
  inline Sq3StmtC* Sq3StmtC::PrepareV3 (Sq3LiteC* db, const std::string& zSql, Sq3PrepareEF prepFlags)  {
    MkRtSetup_NULL;
    SQ3_STMT ppStmt;
    SQ3_LITE db_hdl = Sq3LiteC::getLITE(db);
    const MkStringR zSql_ref = MkStringCreate((MK_NUM)zSql.size(),zSql.c_str());
    enum MkErrorE errVal = Sq3StmtPrepareV3(db_hdl, zSql_ref, prepFlags, &ppStmt);
    MkErrorC_Check(NULL, errVal);
    return Sq3StmtC::Sq3StmtC_ObjCreate(MK_RT_CALL ppStmt);
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-TOR,om_
 
  inline void Sq3StmtC::Finalize ()  {
    MK_UNUSED auto pStmt = getSTMT();
    enum MkErrorE errVal = Sq3StmtFinalize(pStmt);
    MkErrorC_Check(pStmt, errVal);
  }
 
  // Sq3StmtC_TOR_CC_API
 
  //   END-Sq3StmtC - created by 'cc_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
} // END - namespace "ccsq3lite"