Sq3LiteC_cs.cs

Go to the documentation of this file.

 
/* LABEL-INIT */
 
using csmkkernel;
 
/* LABEL-START */
 
using System;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Collections.Generic;
using System.Threading;
 
namespace cssq3lite {
 
#if META_IS_OBJECT
  public partial class Sq3LiteC
#else
  public partial class Sq3LiteC : MkObjectC
#endif
  {
    private readonly static ConstructorInfo ctor = getCtor(typeof(Sq3LiteC));
    private readonly static ThreadLocal<Sq3LiteC> MK_NULL = new ThreadLocal<Sq3LiteC>(() => {
      return (Sq3LiteC) atomSelfNull(ctor);
    });
 
    public static Sq3LiteC Sq3LiteC_ObjNew (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (Sq3LiteC) atomObjNew(typeof(Sq3LiteC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static Sq3LiteC Sq3LiteC_ObjCreate (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (Sq3LiteC) atomObjCreate(typeof(Sq3LiteC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static IntPtr Sq3LiteC_SelfCreate (IntPtr mkrt, IntPtr obj, IntPtr env) {
      return atomSelfCreate(ctor, obj, env);
    }
 
    private static void Sq3LiteC_SelfUnlink (IntPtr mkrt, IntPtr self, IntPtr env) {
      atomSelfUnlink(self, env);
    }
 
    internal static void SetupThreadLITE (IntPtr mkrt) {
      Sq3.Sq3CsTypeUpdate(mkrt, Sq3CsTypeLookupE.LITE, Sq3LiteC_SelfCreate, Sq3LiteC_SelfUnlink);
    }
 
    #if !META_STATIC_OVERWRITE
 
    static Sq3LiteC() {
      // M0("Sq3LiteC");
      Sq3Lite.Setup();
      SetupThreadLITE(IntPtr.Zero);
    }
 
    #endif
/* LABEL-END */
 
    internal Sq3LiteC (IntPtr objP) : base(objP) {
    }
 
  } // END - class "Sq3LiteC"
 
  // BEGIN-Sq3LiteC - created by 'cs_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Class-Export,sc_
 
    new public static Sq3LiteC HandleResolve (Int32 netHdl)  {
      IntPtr __retVal__L = Sq3.Sq3LiteHandleResolve(IntPtr.Zero, netHdl);
      return Sq3LiteC.Sq3LiteC_ObjNew(__retVal__L);
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-Class-Export,om_
 
    // skip class-overload: HandleGet = Sq3LiteHandleGet → MkObjectHandleGet
 
    // Sq3LiteC_Class_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Class-Introspection,oc_
 
    new public Sq3LiteC Next ()  {
      IntPtr __retVal__L = Sq3.Sq3LiteNext(hdl);
      return Sq3LiteC.Sq3LiteC_ObjNew(__retVal__L);
    }
 
    new public Sq3LiteC Prev ()  {
      IntPtr __retVal__L = Sq3.Sq3LitePrev(hdl);
      return Sq3LiteC.Sq3LiteC_ObjNew(__retVal__L);
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-Class-Introspection,sc_
 
    new public static Sq3LiteC Instances ()  {
      IntPtr __retVal__L = Sq3.Sq3LiteInstances(IntPtr.Zero);
      return Sq3LiteC.Sq3LiteC_ObjNew(__retVal__L);
    }
 
    // Sq3LiteC_Class_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Class-Misc,sc_
 
    new public static Sq3LiteC GetNull ()  {
      IntPtr __retVal__L = Sq3.Sq3LiteGetNull();
      return Sq3LiteC.Sq3LiteC_ObjNew(__retVal__L);
    }
 
    // Sq3LiteC_Class_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Config,om_
 
    public void BusyTimeout (int ms)  {
      MkErrorE errVal = Sq3.Sq3LiteBusyTimeout(hdl, ms);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void DeclareVtab (string zSQL)  {
      IntPtr zSQL_cstr = Marshal.StringToHGlobalAnsi(zSQL);
      MkErrorE errVal = Sq3.Sq3LiteDeclareVtab(hdl, zSQL_cstr);
      Marshal.FreeHGlobal(zSQL_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ExtendedResultCodes (int onoff)  {
      MkErrorE errVal = Sq3.Sq3LiteExtendedResultCodes(hdl, onoff);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void Limit (Sq3LimitE id, int newVal)  {
      MkErrorE errVal = Sq3.Sq3LiteLimit(hdl, id, newVal);
      MkErrorC.Check(hdl, errVal);
    }
 
    // Sq3LiteC_Config_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Error,om_
 
    public Sq3ErrorE ErrCode ()  {
      Sq3ErrorE __retVal__L = Sq3.Sq3LiteErrCode(hdl);
      return __retVal__L;
    }
 
    public string ErrMsg ()  {
      IntPtr __retVal__L = Sq3.Sq3LiteErrMsg(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public void ErrorOffset ()  {
      MkErrorE errVal = Sq3.Sq3LiteErrorOffset(hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public Sq3ExtendetResultCodesE ExtendetErrCode ()  {
      Sq3ExtendetResultCodesE __retVal__L = Sq3.Sq3LiteExtendetErrCode(hdl);
      return __retVal__L;
    }
 
    public void SystemErrno ()  {
      MkErrorE errVal = Sq3.Sq3LiteSystemErrno(hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-Error,sm_
 
    public static string ErrStr (int arg0)  {
      IntPtr __retVal__L = Sq3.Sq3LiteErrStr(arg0);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // Sq3LiteC_Error_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Execution,om_
 
    public void ExecV2 (string sql, Sq3LiteExecV2CCB callback = null)  {
      Sq3LiteExecV2CB callback_call = Sq3LiteExecV2Call;
      IntPtr sql_cstr = Marshal.StringToHGlobalAnsi(sql);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new Sq3Call(mkrt,callback));
      if (callback_ptr == IntPtr.Zero) callback_call = null;
      MkErrorE errVal = Sq3.Sq3LiteExecV2(mkrt, hdl, sql_cstr, callback_call, callback_ptr);
      Marshal.FreeHGlobal(sql_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ExecV2 (string sql, Sq3LiteExecV2IF callback = null)  {
      Sq3LiteExecV2CB callback_call = Sq3LiteExecV2Call;
      IntPtr sql_cstr = Marshal.StringToHGlobalAnsi(sql);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new Sq3Call(mkrt,callback));
      if (callback_ptr == IntPtr.Zero) callback_call = null;
      MkErrorE errVal = Sq3.Sq3LiteExecV2(mkrt, hdl, sql_cstr, callback_call, callback_ptr);
      Marshal.FreeHGlobal(sql_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void Exec (string sql, Sq3LiteExecCCB callback_data = null)  {
      Sq3Fupu_Sq3LiteExec_callback_call callback_call = Sq3LiteExecCall;
      IntPtr sql_cstr = Marshal.StringToHGlobalAnsi(sql);
      IntPtr callback_data_ptr = callback_data == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new Sq3Call(mkrt,callback_data));
      if (callback_data_ptr == IntPtr.Zero) callback_call = null;
      MkErrorE errVal = Sq3.Sq3LiteExec(hdl, sql_cstr, callback_call, callback_data_ptr);
      Marshal.FreeHGlobal(sql_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void Exec (string sql, Sq3LiteExecIF callback_data = null)  {
      Sq3Fupu_Sq3LiteExec_callback_call callback_call = Sq3LiteExecCall;
      IntPtr sql_cstr = Marshal.StringToHGlobalAnsi(sql);
      IntPtr callback_data_ptr = callback_data == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new Sq3Call(mkrt,callback_data));
      if (callback_data_ptr == IntPtr.Zero) callback_call = null;
      MkErrorE errVal = Sq3.Sq3LiteExec(hdl, sql_cstr, callback_call, callback_data_ptr);
      Marshal.FreeHGlobal(sql_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-Execution,sm_
 
    public static void Sleep (int arg0)  {
      MkErrorE errVal = Sq3.Sq3LiteSleep(arg0);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    // Sq3LiteC_Execution_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Info,om_
 
    public int GetAutocommit ()  {
      Int32 __retVal__L = Sq3.Sq3LiteGetAutocommit(hdl);
      return __retVal__L;
    }
 
    public long LastInsertRowid ()  {
      Int64 __retVal__L = Sq3.Sq3LiteLastInsertRowid(hdl);
      return __retVal__L;
    }
 
    public void TxnState (string zSchema)  {
      IntPtr zSchema_cstr = Marshal.StringToHGlobalAnsi(zSchema);
      MkErrorE errVal = Sq3.Sq3LiteTxnState(hdl, zSchema_cstr);
      Marshal.FreeHGlobal(zSchema_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void VtabOnConflict ()  {
      MkErrorE errVal = Sq3.Sq3LiteVtabOnConflict(hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // Sq3LiteC_Info_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Misc,oco
 
    public MkBufferListC DbStatusBFL (Sq3DbStatusE op, bool resetFlg)  {
      IntPtr val_out;
      MkErrorE errVal = Sq3.Sq3LiteDbStatusBFL(mkrt, hdl, op, out val_out, resetFlg);
      MkErrorC.Check(hdl, errVal);
      return MkBufferListC.MkBufferListC_ObjNew(val_out);
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-Misc,om_
 
    public void DbCacheflush ()  {
      MkErrorE errVal = Sq3.Sq3LiteDbCacheflush(hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public string DbFilename (string zDbName)  {
      IntPtr zDbName_cstr = Marshal.StringToHGlobalAnsi(zDbName);
      IntPtr __retVal__L = Sq3.Sq3LiteDbFilename(hdl, zDbName_cstr);
      Marshal.FreeHGlobal(zDbName_cstr);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public string DbName (int N)  {
      IntPtr __retVal__L = Sq3.Sq3LiteDbName(hdl, N);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public void DbReadonly (string zDbName)  {
      IntPtr zDbName_cstr = Marshal.StringToHGlobalAnsi(zDbName);
      MkErrorE errVal = Sq3.Sq3LiteDbReadonly(hdl, zDbName_cstr);
      Marshal.FreeHGlobal(zDbName_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void DbReleaseMemory ()  {
      MkErrorE errVal = Sq3.Sq3LiteDbReleaseMemory(hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void Deserialize (string zSchema, byte[] pData, Sq3DeSerializeEF mFlags)  {
      IntPtr zSchema_cstr = Marshal.StringToHGlobalAnsi(zSchema);
      var pData_size = Marshal.SizeOf(pData[0]) * pData.Length;
      var pData_data = Marshal.AllocHGlobal(pData_size);
      Marshal.Copy(pData,0,pData_data,pData_size);
      Mk.MkBinaryR pData_ref = Mk.MkBinaryCreate(pData_size,pData_data);
      MkErrorE errVal = Sq3.Sq3LiteDeserialize(mkrt, hdl, zSchema_cstr, pData_ref, mFlags);
      Marshal.FreeHGlobal(zSchema_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void DropModules (MkBufferListC azKeepBfl)  {
      IntPtr azKeepBfl_hdl = MkBufferListC.getOBJ("MkBufferListC",azKeepBfl);
      MkErrorE errVal = Sq3.Sq3LiteDropModules(mkrt, hdl, azKeepBfl_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // skip class-overload: Log = Sq3LiteLog → MkObjectLog
 
    public void OverloadFunction (string zFuncName, int nArg)  {
      IntPtr zFuncName_cstr = Marshal.StringToHGlobalAnsi(zFuncName);
      MkErrorE errVal = Sq3.Sq3LiteOverloadFunction(hdl, zFuncName_cstr, nArg);
      Marshal.FreeHGlobal(zFuncName_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public byte[] Serialize (string zSchema, Sq3SerializeE mFlags)  {
      IntPtr zSchema_cstr = Marshal.StringToHGlobalAnsi(zSchema);
      Mk.MkBinaryR __retVal__L = Sq3.Sq3LiteSerialize(hdl, zSchema_cstr, mFlags);
      Marshal.FreeHGlobal(zSchema_cstr);
      int __retVal__L_size = (int) __retVal__L.size;
      byte[] ____retVal__L__S = new byte[__retVal__L_size];
      Marshal.Copy(__retVal__L.data,____retVal__L__S,0,(int)__retVal__L_size);
      return ____retVal__L__S;
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-Misc,omo
 
    public List<object> DbStatus (Sq3DbStatusE op, bool resetFlg)  {
      Int32 pCur;
      Int32 pHiwtr;
      MkErrorE errVal = Sq3.Sq3LiteDbStatus(hdl, op, out pCur, out pHiwtr, resetFlg);
      MkErrorC.Check(hdl, errVal);
      List<object> __retVal__L = new List<object>();
      __retVal__L.Add(pCur);
      __retVal__L.Add(pHiwtr);
      return __retVal__L;
    }
 
    public List<object> TableColumnMetadata (string zDbName, string zTableName, string zColumnName)  {
      IntPtr pzDataType;
      IntPtr pzCollSeq;
      Int32 pNotNull;
      Int32 pPrimaryKey;
      Int32 pAutoinc;
      IntPtr zDbName_cstr = Marshal.StringToHGlobalAnsi(zDbName);
      IntPtr zTableName_cstr = Marshal.StringToHGlobalAnsi(zTableName);
      IntPtr zColumnName_cstr = Marshal.StringToHGlobalAnsi(zColumnName);
      MkErrorE errVal = Sq3.Sq3LiteTableColumnMetadata(hdl, zDbName_cstr, zTableName_cstr, zColumnName_cstr, out pzDataType, out pzCollSeq, out pNotNull, out pPrimaryKey, out pAutoinc);
      Marshal.FreeHGlobal(zDbName_cstr);
      Marshal.FreeHGlobal(zTableName_cstr);
      Marshal.FreeHGlobal(zColumnName_cstr);
      MkErrorC.Check(hdl, errVal);
      List<object> __retVal__L = new List<object>();
      __retVal__L.Add(pzDataType);
      __retVal__L.Add(pzCollSeq);
      __retVal__L.Add(pNotNull);
      __retVal__L.Add(pPrimaryKey);
      __retVal__L.Add(pAutoinc);
      return __retVal__L;
    }
 
    // Sq3LiteC_Misc_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,om_
 
    public void WalAutocheckpoint (int N)  {
      MkErrorE errVal = Sq3.Sq3LiteWalAutocheckpoint(hdl, N);
      MkErrorC.Check(hdl, errVal);
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-Modify-Wal,omo
 
    public List<object> WalCheckpointV2 (string zDb, int eMode)  {
      Int32 pnLog;
      Int32 pnCkpt;
      IntPtr zDb_cstr = Marshal.StringToHGlobalAnsi(zDb);
      MkErrorE errVal = Sq3.Sq3LiteWalCheckpointV2(hdl, zDb_cstr, eMode, out pnLog, out pnCkpt);
      Marshal.FreeHGlobal(zDb_cstr);
      MkErrorC.Check(hdl, errVal);
      List<object> __retVal__L = new List<object>();
      __retVal__L.Add(pnLog);
      __retVal__L.Add(pnCkpt);
      return __retVal__L;
    }
 
    // Sq3LiteC_Modify_Wal_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Query,om_
 
    public void Interrupt ()  {
      Sq3.Sq3LiteInterrupt(hdl);
    }
 
    public bool IsInterrupted ()  {
      bool __retVal__L = Sq3.Sq3LiteIsInterrupted(hdl);
      return __retVal__L;
    }
 
    // Sq3LiteC_Query_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-Row,om_
 
    public int Changes ()  {
      Int32 __retVal__L = Sq3.Sq3LiteChanges(hdl);
      return __retVal__L;
    }
 
    public long Changes64 ()  {
      Int64 __retVal__L = Sq3.Sq3LiteChanges64(hdl);
      return __retVal__L;
    }
 
    public void SetLastInsertRowid (long arg1)  {
      Sq3.Sq3LiteSetLastInsertRowid(hdl, arg1);
    }
 
    public int TotalChanges ()  {
      Int32 __retVal__L = Sq3.Sq3LiteTotalChanges(hdl);
      return __retVal__L;
    }
 
    public long TotalChanges64 ()  {
      Int64 __retVal__L = Sq3.Sq3LiteTotalChanges64(hdl);
      return __retVal__L;
    }
 
    // Sq3LiteC_Row_CS_API
  }
 
  public partial class Sq3LiteC {
 
 
    // doc-key: Sq3LiteC,Sq3LiteC-TOR,sCo
 
    protected static IntPtr CTOR (string filename, Sq3OpenEF flags = Sq3OpenEF.READWRITE|Sq3OpenEF.CREATE, string zVfs = null)  {
      IntPtr ppDb;
      IntPtr filename_cstr = Marshal.StringToHGlobalAnsi(filename);
      IntPtr zVfs_cstr = Marshal.StringToHGlobalAnsi(zVfs);
      MkErrorE errVal = Sq3.Sq3LiteOpenV2(filename_cstr, out ppDb, flags, zVfs_cstr);
      Marshal.FreeHGlobal(filename_cstr);
      Marshal.FreeHGlobal(zVfs_cstr);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return (IntPtr)ppDb;
    }
 
    public Sq3LiteC(string filename, Sq3OpenEF flags = Sq3OpenEF.READWRITE|Sq3OpenEF.CREATE, string zVfs = null) : this(CTOR(filename, flags, zVfs)) {}
 
    public static Sq3LiteC OpenV2 (string filename, Sq3OpenEF flags = Sq3OpenEF.READWRITE|Sq3OpenEF.CREATE, string zVfs = null)  {
      IntPtr ppDb;
      IntPtr filename_cstr = Marshal.StringToHGlobalAnsi(filename);
      IntPtr zVfs_cstr = Marshal.StringToHGlobalAnsi(zVfs);
      MkErrorE errVal = Sq3.Sq3LiteOpenV2(filename_cstr, out ppDb, flags, zVfs_cstr);
      Marshal.FreeHGlobal(filename_cstr);
      Marshal.FreeHGlobal(zVfs_cstr);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return Sq3LiteC.Sq3LiteC_ObjCreate(ppDb);
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-TOR,oco
 
    public Sq3StmtC PrepareV2 (string zSql)  {
      IntPtr ppStmt;
      IntPtr zSql_ref_cstr = Marshal.StringToHGlobalAnsi(zSql);
      Mk.MkStringR zSql_ref = Mk.MkStringCreate_1(zSql_ref_cstr);
      MkErrorE errVal = Sq3.Sq3LitePrepareV2(hdl, zSql_ref, out ppStmt);
      Marshal.FreeHGlobal(zSql_ref_cstr);
      MkErrorC.Check(hdl, errVal);
      return Sq3StmtC.Sq3StmtC_ObjNew(ppStmt);
    }
 
    // doc-key: Sq3LiteC,Sq3LiteC-TOR,om_
 
    public void CloseV2 ()  {
      MkErrorE errVal = Sq3.Sq3LiteCloseV2(hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // Sq3LiteC_TOR_CS_API
  }
 
  // END-Sq3LiteC - created by 'cs_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
} // END - namespace "cssq3lite"