Sq3StmtC_sq3.h

Go to the documentation of this file.

 
/* LABEL-START */
#pragma once
 
#include "LibSq3Lite_sq3.h"
/* LABEL-END */
 
#include "Sq3StmtC_def_sq3.h"
#include "Sq3LiteC_def_sq3.h"
 
BEGIN_SQ3_C_DECLS
 
// =========================================================================
// BEGIN-Sq3StmtC-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: Sq3StmtC,Sq3StmtC-Bind,om_
 
    #define Sq3Fupu_Sq3StmtBindBlob64Hide_cb_ret  void
    #define Sq3Fupu_Sq3StmtBindBlob64Hide_cb_args MK_PTR arg0
    typedef Sq3Fupu_Sq3StmtBindBlob64Hide_cb_ret (*Sq3Fupu_Sq3StmtBindBlob64Hide_cb) (Sq3Fupu_Sq3StmtBindBlob64Hide_cb_args);
 
    #define Sq3Fupu_Sq3StmtBindBlobHide_cb_ret  void
    #define Sq3Fupu_Sq3StmtBindBlobHide_cb_args MK_PTR arg0
    typedef Sq3Fupu_Sq3StmtBindBlobHide_cb_ret (*Sq3Fupu_Sq3StmtBindBlobHide_cb) (Sq3Fupu_Sq3StmtBindBlobHide_cb_args);
 
    #define Sq3Fupu_Sq3StmtBindPointer_arg4_ret  void
    #define Sq3Fupu_Sq3StmtBindPointer_arg4_args MK_PTR arg0
    typedef Sq3Fupu_Sq3StmtBindPointer_arg4_ret (*Sq3Fupu_Sq3StmtBindPointer_arg4) (Sq3Fupu_Sq3StmtBindPointer_arg4_args);
 
    #define Sq3Fupu_Sq3StmtBindText64Hide_cb_ret  void
    #define Sq3Fupu_Sq3StmtBindText64Hide_cb_args MK_PTR arg0
    typedef Sq3Fupu_Sq3StmtBindText64Hide_cb_ret (*Sq3Fupu_Sq3StmtBindText64Hide_cb) (Sq3Fupu_Sq3StmtBindText64Hide_cb_args);
 
    #define Sq3Fupu_Sq3StmtBindTextHide_cb_ret  void
    #define Sq3Fupu_Sq3StmtBindTextHide_cb_args MK_PTR arg0
    typedef Sq3Fupu_Sq3StmtBindTextHide_cb_ret (*Sq3Fupu_Sq3StmtBindTextHide_cb) (Sq3Fupu_Sq3StmtBindTextHide_cb_args);
#endif
 
// END-Sq3StmtC-fupu - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// =========================================================================
// BEGIN-Sq3StmtC-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: Sq3StmtC,Sq3StmtC-Bind,om_
 
  mk_inline enum MkErrorE Sq3StmtBindBlob64Hide (SQ3_STMT sq3stmt, MK_I32 pos, MK_PTRN blob, MK_I64 len, Sq3Fupu_Sq3StmtBindBlob64Hide_cb cb) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_blob64(sq3stmt->nat, pos, blob, (MK_U64)len, cb);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindBlobHide (SQ3_STMT sq3stmt, MK_I32 pos, MK_PTRN blob, MK_I32 len, Sq3Fupu_Sq3StmtBindBlobHide_cb cb) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_blob(sq3stmt->nat, pos, blob, len, cb);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindDouble (SQ3_STMT sq3stmt, MK_I32 arg1, MK_DBL arg2) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_double(sq3stmt->nat, arg1, arg2);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindInt (SQ3_STMT sq3stmt, MK_I32 arg1, MK_I32 arg2) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_int(sq3stmt->nat, arg1, arg2);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindInt64 (SQ3_STMT sq3stmt, MK_I32 arg1, MK_I64 arg2) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_int64(sq3stmt->nat, arg1, arg2);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindNull (SQ3_STMT sq3stmt, MK_I32 arg1) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_null(sq3stmt->nat, arg1);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindParameterCount (SQ3_STMT sq3stmt) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_parameter_count(sq3stmt->nat);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindParameterIndex (SQ3_STMT sq3stmt, MK_STRN zName) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_parameter_index(sq3stmt->nat, zName);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline MK_STRN Sq3StmtBindParameterName (SQ3_STMT sq3stmt, MK_I32 arg1) {
    SQ3_INSTANCE_HDL(sq3stmt);
    MK_STRN __retVal__L = sqlite3_bind_parameter_name(sq3stmt->nat, arg1);
    return __retVal__L;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindPointer (SQ3_STMT sq3stmt, MK_I32 arg1, MK_PTR arg2, MK_STRN arg3, Sq3Fupu_Sq3StmtBindPointer_arg4 arg4) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_pointer(sq3stmt->nat, arg1, (MK_PTR)(arg2), arg3, arg4);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindText64Hide (SQ3_STMT sq3stmt, MK_I32 pos, MK_STRN text, MK_I64 len, Sq3Fupu_Sq3StmtBindText64Hide_cb cb, enum Sq3TextE encoding) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_text64(sq3stmt->nat, pos, text, (MK_U64)len, cb, encoding);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindTextHide (SQ3_STMT sq3stmt, MK_I32 pos, MK_STRN text, MK_I32 len, Sq3Fupu_Sq3StmtBindTextHide_cb cb) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_text(sq3stmt->nat, pos, text, len, cb);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindValue (SQ3_STMT sq3stmt, MK_I32 arg1, SQ3_VALN arg2) {
    SQ3_INSTANCE_HDL(sq3stmt);
    const struct sqlite3_value * arg2_hdl = arg2->nat;
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_value(sq3stmt->nat, arg1, arg2_hdl);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindZeroblob (SQ3_STMT sq3stmt, MK_I32 arg1, MK_I32 n) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_zeroblob(sq3stmt->nat, arg1, n);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtBindZeroblob64 (SQ3_STMT sq3stmt, MK_I32 arg1, MK_I64 arg2) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_bind_zeroblob64(sq3stmt->nat, arg1, (MK_U64)arg2);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3StmtC,Sq3StmtC-Column,oc_
 
  mk_inline SQ3_VAL Sq3StmtColumnValue (SQ3_STMT sq3stmt, MK_I32 iCol) {
    SQ3_INSTANCE_HDL(sq3stmt);
    return Sq3ValueC_ObjNew(sqlite3_column_value(sq3stmt->nat, iCol));
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Column,om_
 
  mk_inline MK_BINN Sq3StmtColumnBlobHide (SQ3_STMT sq3stmt, MK_I32 iCol) {
    SQ3_INSTANCE_HDL(sq3stmt);
    return (MK_BINN)sqlite3_column_blob(sq3stmt->nat, iCol);
  }
 
  mk_inline MK_I32 Sq3StmtColumnBytes (SQ3_STMT sq3stmt, MK_I32 iCol) {
    SQ3_INSTANCE_HDL(sq3stmt);
    return sqlite3_column_bytes(sq3stmt->nat, iCol);
  }
 
  mk_inline MK_I32 Sq3StmtColumnCount (SQ3_STMT pStmt) {
    SQ3_INSTANCE_HDL(pStmt);
    return sqlite3_column_count(pStmt->nat);
  }
 
  mk_inline MK_DBL Sq3StmtColumnDouble (SQ3_STMT sq3stmt, MK_I32 iCol) {
    SQ3_INSTANCE_HDL(sq3stmt);
    return sqlite3_column_double(sq3stmt->nat, iCol);
  }
 
  mk_inline MK_I32 Sq3StmtColumnInt (SQ3_STMT sq3stmt, MK_I32 iCol) {
    SQ3_INSTANCE_HDL(sq3stmt);
    return sqlite3_column_int(sq3stmt->nat, iCol);
  }
 
  mk_inline MK_I64 Sq3StmtColumnInt64 (SQ3_STMT sq3stmt, MK_I32 iCol) {
    SQ3_INSTANCE_HDL(sq3stmt);
    return sqlite3_column_int64(sq3stmt->nat, iCol);
  }
 
  mk_inline MK_STRN Sq3StmtColumnName (SQ3_STMT sq3stmt, MK_I32 N) {
    SQ3_INSTANCE_HDL(sq3stmt);
    MK_STRN __retVal__L = sqlite3_column_name(sq3stmt->nat, N);
    return __retVal__L;
  }
 
  mk_inline MK_STRN Sq3StmtColumnTextHide (SQ3_STMT sq3stmt, MK_I32 iCol) {
    SQ3_INSTANCE_HDL(sq3stmt);
    MK_STRN __retVal__L = (MK_STRN)sqlite3_column_text(sq3stmt->nat, iCol);
    return __retVal__L;
  }
 
  mk_inline enum Sq3TypeE Sq3StmtColumnType (SQ3_STMT sq3stmt, MK_I32 iCol) {
    SQ3_INSTANCE_HDL(sq3stmt);
    return (enum Sq3TypeE)sqlite3_column_type(sq3stmt->nat, iCol);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3StmtC,Sq3StmtC-Info,oc_
 
  mk_inline SQ3_LITE Sq3StmtDbHandle (SQ3_STMT sq3stmt) {
    SQ3_INSTANCE_HDL(sq3stmt);
    return Sq3LiteC_ObjNew(sqlite3_db_handle(sq3stmt->nat));
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Info,om_
 
  mk_inline enum MkErrorE Sq3StmtBusy (SQ3_STMT sq3stmt) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_stmt_busy(sq3stmt->nat);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtDataCount (SQ3_STMT pStmt) {
    SQ3_INSTANCE_HDL(pStmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_data_count(pStmt->nat);
    Sq3ErrorE_Check(pStmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtIsExplain (SQ3_STMT pStmt) {
    SQ3_INSTANCE_HDL(pStmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_stmt_isexplain(pStmt->nat);
    Sq3ErrorE_Check(pStmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtReadonly (SQ3_STMT pStmt) {
    SQ3_INSTANCE_HDL(pStmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_stmt_readonly(pStmt->nat);
    Sq3ErrorE_Check(pStmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtStatus (SQ3_STMT sq3stmt, enum Sq3StmtStatusE op, MK_BOOL resetFlg) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_stmt_status(sq3stmt->nat, op, resetFlg);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3StmtC,Sq3StmtC-Misc,sc_
 
  mk_inline SQ3_STMT Sq3StmtNextStmt (SQ3_LITE pDb, SQ3_STMT pStmt) {
    struct sqlite3 * pDb_hdl = pDb->nat;
    struct sqlite3_stmt * pStmt_hdl = pStmt->nat;
    return Sq3StmtC_ObjNew(sqlite3_next_stmt(pDb_hdl, pStmt_hdl));
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Misc,om_
 
  mk_inline enum MkErrorE Sq3StmtClearBindings (SQ3_STMT sq3stmt) {
    SQ3_INSTANCE_HDL(sq3stmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_clear_bindings(sq3stmt->nat);
    Sq3ErrorE_Check(sq3stmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtExplain (SQ3_STMT pStmt, MK_I32 eMode) {
    SQ3_INSTANCE_HDL(pStmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_stmt_explain(pStmt->nat, eMode);
    Sq3ErrorE_Check(pStmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtReset (SQ3_STMT pStmt) {
    SQ3_INSTANCE_HDL(pStmt);
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_reset(pStmt->nat);
    Sq3ErrorE_Check(pStmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-Misc,omo
 
  mk_inline enum MkErrorE Sq3StmtStep (SQ3_STMT sq3stmt, enum Sq3ErrorE *retCode); // skip template-required
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3StmtC,Sq3StmtC-Sql,om_
 
  mk_inline MK_STR Sq3StmtExpandedSql (SQ3_STMT pStmt) {
    SQ3_INSTANCE_HDL(pStmt);
    MK_STR __retVal__L = sqlite3_expanded_sql(pStmt->nat);
    return __retVal__L;
  }
 
  mk_inline MK_STRN Sq3StmtSql (SQ3_STMT pStmt) {
    SQ3_INSTANCE_HDL(pStmt);
    MK_STRN __retVal__L = sqlite3_sql(pStmt->nat);
    return __retVal__L;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: Sq3StmtC,Sq3StmtC-TOR,sC_
 
  mk_inline enum MkErrorE Sq3StmtPrepareV2Hide (SQ3_LITE db, MK_STRN zSql, MK_I32 nByte, SQ3_STMT *ppStmt, MK_STRN *pzTail) {
    *ppStmt = NULL;
    struct sqlite3 * db_hdl = db->nat;
    sqlite3_stmt* ppStmt_val = NULL;
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_prepare_v2(db_hdl, zSql, nByte, &ppStmt_val, pzTail);
    *ppStmt = Sq3StmtC_ObjCreate(ppStmt_val);
    Sq3ErrorE_Check_Static(Sq3StmtC_TT,errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE Sq3StmtPrepareV3Hide (SQ3_LITE db, MK_STRN zSql, MK_I32 nByte, enum Sq3PrepareEF prepFlags, SQ3_STMT *ppStmt, MK_STRN *pzTail) {
    *ppStmt = NULL;
    struct sqlite3 * db_hdl = db->nat;
    sqlite3_stmt* ppStmt_val = NULL;
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_prepare_v3(db_hdl, zSql, nByte, prepFlags, &ppStmt_val, pzTail);
    *ppStmt = Sq3StmtC_ObjCreate(ppStmt_val);
    Sq3ErrorE_Check_Static(Sq3StmtC_TT,errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  // doc-key: Sq3StmtC,Sq3StmtC-TOR,om_
 
  mk_inline enum MkErrorE Sq3StmtFinalize (SQ3_STMT pStmt) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_finalize(pStmt->nat);
    Sq3ErrorE_Check(pStmt, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
// END-Sq3StmtC-inline - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// ==========================================================================================
// OVERLOAD
//
 
__parser__(class=Sq3StmtC,constructor,lng-constr)
MK_ATTR_RT_STATIC
mk_inline enum MkErrorE Sq3StmtPrepareV2 (
  SQ3_LITE  db, 
  MkStringR zSql, 
  SQ3_STMT  *ppStmt   __parser__(out)
) {
  assert (db != NULL);
  MkRtSetup_XN(db);
  MK_STRN pzTail = NULL;
  MkErrorE_Check(Sq3StmtPrepareV2Hide(db,zSql.ptr,zSql.len,ppStmt,&pzTail));
  (*ppStmt)->pzTail = pzTail;
  MkErrorReturnLabel(db);
} 
 
__parser__(class=Sq3StmtC,constructor)
MK_ATTR_RT_STATIC
mk_inline enum MkErrorE Sq3StmtPrepareV3 (
  SQ3_LITE      db, 
  MkStringR     zSql, 
  Sq3PrepareEF  prepFlags   __parser__(default=SQ3_PREPARE_NO)   ,
  SQ3_STMT      *ppStmt     __parser__(out)
) {
  assert (db != NULL);
  MkRtSetup_XN(db);
  MK_STRN pzTail = NULL;
  MkErrorE_Check(Sq3StmtPrepareV3Hide(db,zSql.ptr,zSql.len,prepFlags,ppStmt,&pzTail));
  (*ppStmt)->pzTail = pzTail;
  MkErrorReturnLabel(db);
} 
 
__parser__(doc-group=Sql)
MK_ATTR_INSTANCE
mk_inline MK_STRN Sq3StmtGetPzTail (
  SQ3_STMT  sq3stmt
) {
  SQ3_INSTANCE_HDL(sq3stmt);
  return sq3stmt->pzTail ? sq3stmt->pzTail : MK_NULL_STR;
} 
 
__parser__(hide)
MK_ATTR_RT_INSTANCE
mk_inline enum MkErrorE Sq3StmtBindText64_RT (
  MK_PARSER_RT
  SQ3_STMT      sq3stmt, 
  MK_I32        pos, 
  MkStringR     text,
  enum Sq3TextE encoding
) {
  SQ3_INSTANCE_RT_X(sq3stmt);
  MkErrorCheck(Sq3StmtBindText64Hide(sq3stmt, pos, text.ptr, text.len, SQLITE_TRANSIENT, encoding));
  MkErrorReturnLabel(sq3stmt);
} 
 
MK_ATTR_INSTANCE
mk_inline enum MkErrorE Sq3StmtBindText_RT (
  MK_PARSER_RT
  SQ3_STMT      sq3stmt, 
  MK_I32        pos, 
  MkStringR     text
) {
  SQ3_INSTANCE_RT_X(sq3stmt);
  MkErrorCheck(Sq3StmtBindTextHide(sq3stmt, pos, text.ptr, text.len, SQLITE_TRANSIENT));
  MkErrorReturnLabel(sq3stmt);
} 
 
__parser__(hide)
MK_ATTR_INSTANCE
mk_inline enum MkErrorE Sq3StmtBindBlob64_RT (
  MK_PARSER_RT
  SQ3_STMT      sq3stmt, 
  MK_I32        pos, 
  MkBinaryR     blob
) {
  SQ3_INSTANCE_RT_X(sq3stmt);
  MkErrorCheck(Sq3StmtBindBlob64Hide(sq3stmt, pos, blob.data, blob.size, SQLITE_TRANSIENT));
  MkErrorReturnLabel(sq3stmt);
} 
 
MK_ATTR_INSTANCE
mk_inline enum MkErrorE Sq3StmtBindBlob_RT (
  MK_PARSER_RT
  SQ3_STMT      sq3stmt, 
  MK_I32        pos, 
  MkBinaryR     blob
) {
  SQ3_INSTANCE_RT_X(sq3stmt);
  MkErrorCheck(Sq3StmtBindBlobHide(sq3stmt, pos, blob.data, (MK_I32) blob.size, SQLITE_TRANSIENT));
  MkErrorReturnLabel(sq3stmt);
} 
  
MK_ATTR_INSTANCE
mk_inline MkBinaryR Sq3StmtColumnBlob (SQ3_STMT sq3stmt, MK_I32 iCol) {
  SQ3_INSTANCE_HDL(sq3stmt);
  MK_BINN bin = Sq3StmtColumnBlobHide(sq3stmt,iCol);
  return MkBinaryCreate(Sq3StmtColumnBytes(sq3stmt,iCol),bin);
} 
  
MK_ATTR_INSTANCE
mk_inline MkStringR Sq3StmtColumnText (SQ3_STMT sq3stmt, MK_I32 iCol) {
  SQ3_INSTANCE_HDL(sq3stmt);
  MK_STRN str = Sq3StmtColumnTextHide(sq3stmt,iCol);
  return MkStringCreate(Sq3StmtColumnBytes(sq3stmt,iCol),str);
} 
 
MK_ATTR_INSTANCE
mk_inline enum MkErrorE Sq3StmtStep (SQ3_STMT sq3stmt, enum Sq3ErrorE *retCode) {
  SQ3_INSTANCE_HDL(sq3stmt);
  enum Sq3ErrorE errVal = *retCode = (enum Sq3ErrorE)sqlite3_step(sq3stmt->nat);
  Sq3ErrorE_Check(sq3stmt, errVal);
  
  return MK_OK;
error:
  return MK_ERROR;
} 
 
__parser__(const,class-overload=MkObjectLog,doc-group=Info)
SQ3_EXTERN void MK_DECL Sq3StmtLog_RT (
  MK_PARSER_RT
  SQ3_STMT const stmt       ,
  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 ;
 
END_SQ3_C_DECLS