I need some help with Sqlite3 DLL, plz.

[KingRat]

Hi folks,
Im trying to use Sqlite3 under QB64, I´ve downloaded the DLL and the C++ header (both in the same path as qb64).

I´m reading both the header file and some online material to figure out how to do it.

But I don´t know how to declare the following function (present in the header):

int sqlite3_open(
  const char *filename,   /* Database filename (UTF-8) */
  sqlite3 **ppDb          /* OUT: SQLite db handle */
);

So, *filename is a pointer to the first char in the string? Like " _OFFSET(dbFileName$) for example?
And **ppDb isn´t an input pointer, but it outputs data?

Thanks to everyone!

[KingRat]

By the way, its better use Dynamic or a Customtype library?

[KingRat]

Here is the DLL and the H file.

Code: QB64: [Select]

1. 'These two simple procedures returns no errors
2.  
3. DECLARE DYNAMIC LIBRARY "sqlite3"
4.     SUB initSql ALIAS sqlite3_initialize ()
5.     SUB stopSql ALIAS sqlite3_shutdown ()
6.    
7. END DECLARE
8.  

I´m trying to implement this function now, but im getting errors when I try to use it. I guess Im not passing the parameters correctly.

Code: QB64: [Select]

1. int sqlite3_open(
2.   const char *filename,   /* Database filename (UTF-8) */
3.   sqlite3 **ppDb          /* OUT: SQLite db handle */
4. );
5.  

[TempodiBasic]

Hi KingRat
you are touching a field very interesting for me but not in this moment.
So for now I can only give you my opinion.

See documentation about SQL3 at these webpages...
https://www.sqlite.org/c3ref/intro.html
https://www.sqlite.org/c3ref/funclist.html
https://www.sqlite.org/c3ref/initialize.html
https://www.sqlite.org/c3ref/open.html
and seeing QB64 documantation about external library and C functions at these wikipages...
http://qb64.org/wiki/DECLARE_LIBRARY
http://qb64.org/wiki/DECLARE_DYNAMIC_LIBRARY
http://qb64.org/wiki/C_Libraries

and  seeing this documentation C example

01  #include <stdio.h>
02  #include <sqlite3.h>
03 
04  static int callback(void *NotUsed, int argc, char **argv, char **azColName){
05    int i;
06    for(i=0; i<argc; i++){
07      printf("%s = %s\n", azColName, argv ? argv : "NULL");
08    }
09    printf("\n");
10    return 0;
11  }
12 
13  int main(int argc, char **argv){
14    sqlite3 *db;
15    char *zErrMsg = 0;
16    int rc;
17 
18    if( argc!=3 ){
19      fprintf(stderr, "Usage: %s DATABASE SQL-STATEMENT\n", argv[0]);
20      return(1);
21    }
22    rc = sqlite3_open(argv[1], &db);
23    if( rc ){
24      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
25      sqlite3_close(db);
26      return(1);
27    }
28    rc = sqlite3_exec(db, argv[2], callback, 0, &zErrMsg);
29    if( rc!=SQLITE_OK ){
30      fprintf(stderr, "SQL error: %s\n", zErrMsg);
31      sqlite3_free(zErrMsg);
32    }
33    sqlite3_close(db);
34    return 0;

I can affirm that
1. it is very useful to gain sqlite3.h to have the declaration fo type of data used in sqlite3
2. it seems better to define strictly_type the function of the DLL, so it is easier to manage a database, so why don't declare as function initSql and StopSql?
3. **ppDb is an handle to the specific dataType of database that in this documantation is undefined! So how can I manage and take informations from ppDB?

but this code seems to work to open a database Test.db with a dimension of  0 kb .

[KingRat]

Thanks for reply my topic, TempodiBasic!!!

I´m into the sqlite documentation pages for three days now... :/

I´m trying to isolate the sqlite3 struct by hand from its source code, but the bad thing about these "opaque structs" is that the typedefs are not located at the same block....

Here is a small amount of what´s going on!

Code: QB64: [Select]

1. typedef sqlite_int64 i64;          /* 8-byte signed integer */
2. typedef sqlite_uint64 u64;         /* 8-byte unsigned integer */
3. typedef UINT32_TYPE u32;           /* 4-byte unsigned integer */
4. typedef UINT16_TYPE u16;           /* 2-byte unsigned integer */
5. typedef INT16_TYPE i16;            /* 2-byte signed integer */
6. typedef UINT8_TYPE u8;             /* 1-byte unsigned integer */
7. typedef INT8_TYPE i8;
8.  
9. struct CollSeq {
10.   char *zName;          /* Name of the collating sequence, UTF-8 encoded */
11.   u8 enc;               /* Text encoding handled by xCmp() */
12.   void *pUser;          /* First argument to xCmp() */
13.   int (*xCmp)(void*,int, const void*, int, const void*);
14.   void (*xDel)(void*);  /* Destructor for pUser */
15. };
16.  
17. typedef void (*sqlite3_syscall_ptr)(void);
18.  
19. #ifdef SQLITE_INT64_TYPE
20.   typedef SQLITE_INT64_TYPE sqlite_int64;
21. # ifdef SQLITE_UINT64_TYPE
22.     typedef SQLITE_UINT64_TYPE sqlite_uint64;
23. # else  
24.     typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
25. # endif
26. #elif defined(_MSC_VER) || defined(__BORLANDC__)
27.   typedef __int64 sqlite_int64;
28.   typedef unsigned __int64 sqlite_uint64;
29. #else
30.   typedef long long int sqlite_int64;
31.   typedef unsigned long long int sqlite_uint64;
32. #endif
33. typedef sqlite_int64 sqlite3_int64;
34. typedef sqlite_uint64 sqlite3_uint64;
35.  
36. struct sqlite3_file {
37.   const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
38. };
39.  
40. struct sqlite3_vfs {
41.   int iVersion;            /* Structure version number (currently 3) */
42.   int szOsFile;            /* Size of subclassed sqlite3_file */
43.   int mxPathname;          /* Maximum file pathname length */
44.   sqlite3_vfs *pNext;      /* Next registered VFS */
45.   const char *zName;       /* Name of this virtual file system */
46.   void *pAppData;          /* Pointer to application-specific data */
47.   int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
48.                int flags, int *pOutFlags);
49.   int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
50.   int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
51.   int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
52.   void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
53.   void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
54.   void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
55.   void (*xDlClose)(sqlite3_vfs*, void*);
56.   int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
57.   int (*xSleep)(sqlite3_vfs*, int microseconds);
58.   int (*xCurrentTime)(sqlite3_vfs*, double*);
59.   int (*xGetLastError)(sqlite3_vfs*, int, char *);
60.   /*
61.   ** The methods above are in version 1 of the sqlite_vfs object
62.   ** definition.  Those that follow are added in version 2 or later
63.   */
64.   int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);
65.   /*
66.   ** The methods above are in versions 1 and 2 of the sqlite_vfs object.
67.   ** Those below are for version 3 and greater.
68.   */
69.   int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
70.   sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
71.   const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
72.   /*
73.   ** The methods above are in versions 1 through 3 of the sqlite_vfs object.
74.   ** New fields may be appended in future versions.  The iVersion
75.   ** value will increment whenever this happens.
76.   */
77. };
78.  
79. struct sqlite3 {
80.   sqlite3_vfs *pVfs;            /* OS Interface */
81.   struct Vdbe *pVdbe;           /* List of active virtual machines */
82.   CollSeq *pDfltColl;           /* The default collating sequence (BINARY) */
83.   sqlite3_mutex *mutex;         /* Connection mutex */
84.   Db *aDb;                      /* All backends */
85.   int nDb;                      /* Number of backends currently in use */
86.   u32 mDbFlags;                 /* flags recording internal state */
87.   u32 flags;                    /* flags settable by pragmas. See below */
88.   i64 lastRowid;                /* ROWID of most recent insert (see above) */
89.   i64 szMmap;                   /* Default mmap_size setting */
90.   u32 nSchemaLock;              /* Do not reset the schema when non-zero */
91.   unsigned int openFlags;       /* Flags passed to sqlite3_vfs.xOpen() */
92.   int errCode;                  /* Most recent error code (SQLITE_*) */
93.   int errMask;                  /* & result codes with this before returning */
94.   int iSysErrno;                /* Errno value from last system error */
95.   u16 dbOptFlags;               /* Flags to enable/disable optimizations */
96.   u8 enc;                       /* Text encoding */
97.   u8 autoCommit;                /* The auto-commit flag. */
98.   u8 temp_store;                /* 1: file 2: memory 0: default */
99.   u8 mallocFailed;              /* True if we have seen a malloc failure */
100.   u8 bBenignMalloc;             /* Do not require OOMs if true */
101.   u8 dfltLockMode;              /* Default locking-mode for attached dbs */
102.   signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */
103.   u8 suppressErr;               /* Do not issue error messages if true */
104.   u8 vtabOnConflict;            /* Value to return for s3_vtab_on_conflict() */
105.   u8 isTransactionSavepoint;    /* True if the outermost savepoint is a TS */
106.   u8 mTrace;                    /* zero or more SQLITE_TRACE flags */
107.   u8 noSharedCache;             /* True if no shared-cache backends */
108.   u8 nSqlExec;                  /* Number of pending OP_SqlExec opcodes */
109.   int nextPagesize;             /* Pagesize after VACUUM if >0 */
110.   u32 magic;                    /* Magic number for detect library misuse */
111.   int nChange;                  /* Value returned by sqlite3_changes() */
112.   int nTotalChange;             /* Value returned by sqlite3_total_changes() */
113.   int aLimit[SQLITE_N_LIMIT];   /* Limits */
114.   int nMaxSorterMmap;           /* Maximum size of regions mapped by sorter */
115.   struct sqlite3InitInfo {      /* Information used during initialization */
116.     int newTnum;                /* Rootpage of table being initialized */
117.     u8 iDb;                     /* Which db file is being initialized */
118.     u8 busy;                    /* TRUE if currently initializing */
119.     unsigned orphanTrigger : 1; /* Last statement is orphaned TEMP trigger */
120.     unsigned imposterTable : 1; /* Building an imposter table */
121.     unsigned reopenMemdb : 1;   /* ATTACH is really a reopen using MemDB */
122.   } init;
123.   int nVdbeActive;              /* Number of VDBEs currently running */
124.   int nVdbeRead;                /* Number of active VDBEs that read or write */
125.   int nVdbeWrite;               /* Number of active VDBEs that read and write */
126.   int nVdbeExec;                /* Number of nested calls to VdbeExec() */
127.   int nVDestroy;                /* Number of active OP_VDestroy operations */
128.   int nExtension;               /* Number of loaded extensions */
129.   void **aExtension;            /* Array of shared library handles */
130.   int (*xTrace)(u32,void*,void*,void*);     /* Trace function */
131.   void *pTraceArg;                          /* Argument to the trace function */
132.   void (*xProfile)(void*,const char*,u64);  /* Profiling function */
133.   void *pProfileArg;                        /* Argument to profile function */
134.   void *pCommitArg;                 /* Argument to xCommitCallback() */
135.   int (*xCommitCallback)(void*);    /* Invoked at every commit. */
136.   void *pRollbackArg;               /* Argument to xRollbackCallback() */
137.   void (*xRollbackCallback)(void*); /* Invoked at every commit. */
138.   void *pUpdateArg;
139.   void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
140. #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
141.   void *pPreUpdateArg;          /* First argument to xPreUpdateCallback */
142.   void (*xPreUpdateCallback)(   /* Registered using sqlite3_preupdate_hook() */
143.     void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64
144.   );
145.   PreUpdate *pPreUpdate;        /* Context for active pre-update callback */
146. #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
147. #ifndef SQLITE_OMIT_WAL
148.   int (*xWalCallback)(void *, sqlite3 *, const char *, int);
149.   void *pWalArg;
150. #endif
151.   void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
152.   void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
153.   void *pCollNeededArg;
154.   sqlite3_value *pErr;          /* Most recent error message */
155.   union {
156.     volatile int isInterrupted; /* True if sqlite3_interrupt has been called */
157.     double notUsed1;            /* Spacer */
158.   } u1;
159.   Lookaside lookaside;          /* Lookaside malloc configuration */
160. #ifndef SQLITE_OMIT_AUTHORIZATION
161.   sqlite3_xauth xAuth;          /* Access authorization function */
162.   void *pAuthArg;               /* 1st argument to the access auth function */
163. #endif
164. #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
165.   int (*xProgress)(void *);     /* The progress callback */
166.   void *pProgressArg;           /* Argument to the progress callback */
167.   unsigned nProgressOps;        /* Number of opcodes for progress callback */
168. #endif
169. #ifndef SQLITE_OMIT_VIRTUALTABLE
170.   int nVTrans;                  /* Allocated size of aVTrans */
171.   Hash aModule;                 /* populated by sqlite3_create_module() */
172.   VtabCtx *pVtabCtx;            /* Context for active vtab connect/create */
173.   VTable **aVTrans;             /* Virtual tables with open transactions */
174.   VTable *pDisconnect;          /* Disconnect these in next sqlite3_prepare() */
175. #endif
176.   Hash aFunc;                   /* Hash table of connection functions */
177.   Hash aCollSeq;                /* All collating sequences */
178.   BusyHandler busyHandler;      /* Busy callback */
179.   Db aDbStatic[2];              /* Static space for the 2 default backends */
180.   Savepoint *pSavepoint;        /* List of active savepoints */
181.   int busyTimeout;              /* Busy handler timeout, in msec */
182.   int nSavepoint;               /* Number of non-transaction savepoints */
183.   int nStatement;               /* Number of nested statement-transactions  */
184.   i64 nDeferredCons;            /* Net deferred constraints this transaction. */
185.   i64 nDeferredImmCons;         /* Net deferred immediate constraints */
186.   int *pnBytesFreed;            /* If not NULL, increment this in DbFree() */
187. #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
188.   /* The following variables are all protected by the STATIC_MASTER
189.   ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
190.   **
191.   ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
192.   ** unlock so that it can proceed.
193.   **
194.   ** When X.pBlockingConnection==Y, that means that something that X tried
195.   ** tried to do recently failed with an SQLITE_LOCKED error due to locks
196.   ** held by Y.
197.   */
198.   sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */
199.   sqlite3 *pUnlockConnection;           /* Connection to watch for unlock */
200.   void *pUnlockArg;                     /* Argument to xUnlockNotify */
201.   void (*xUnlockNotify)(void **, int);  /* Unlock notify callback */
202.   sqlite3 *pNextBlocked;        /* Next in list of all blocked connections */
203. #endif
204. #ifdef SQLITE_USER_AUTHENTICATION
205.   sqlite3_userauth auth;        /* User authentication information */
206. #endif
207. };
208.  
209. /* ------------------------------------------------------------------------------------------------------------------------------------*/
210.  
211. struct Instancia sqlite3;
212.  
213. int *GetInstancePtr(){
214.         return *Instancia;
215. }
216.  

The function at the end is where I´ll try to send the struct pointer back to the QB64 application to be used.
But QB64 still cant compile it as a .H file cause there are more deftypes out there in the sqlite mess files..

I´will take a look at your code.

Thx!

[KingRat]

Yes, I got your code here
I did some experiences with sqlite3_open function but I deleted it to post here (thats the blank line in the declare library part in my code).
I´ll be playing with that again using long as ppDb, cause I was using offset.

Thanks again!

[TempodiBasic]

Hi KingRat
I find sqlite3.h...
now it must be converted in QB64 compatible type data

grab it here
https://github.com/LuaDist/libsqlite3/blob/master/sqlite3.h

Good Coding

[KingRat]

Hi TempodiBasic!

This is the same file I posted in the first message at this topic. I was travelling, now Im back I´ll restart coding again.

Thanks again!

[KingRat]

Just to keep the topic running.
Im still trying.... I tryed some C/C++ stuff at a .H file....
I´ve downloaded the amalgmation version of sqlite3 to embed it on the aplication but the C++ compiler behind qb64 returns that there were a #endif without a #if...

The following code is a scrap that Im using to try to work with the DLL, I wrote a simple function to return the actual error returned by the DLL functions.

If someone knows how to deal with it please reply!

Code: QB64: [Select]

1. DECLARE DYNAMIC LIBRARY "sqlite3"
2.     FUNCTION StartSqlite% ALIAS sqlite3_initialize ()
3.     FUNCTION StopSqlite% ALIAS sqlite3_shutdown ()
4.     FUNCTION SqliteLibVersion& ALIAS sqlite3_libversion_number ()
5.     FUNCTION OpenDb% ALIAS sqlite3_open (filename AS STRING, ppDb AS _OFFSET)
6.     FUNCTION CloseDb% ALIAS sqlite3_close ()                        
7.    'FUNCTION SqliteExec& ALIAS sqlite3_exec (sqlite3 AS _OFFSET, sql AS STRING, CbackPtr AS _UNSIGNED LONG, Vd AS LONG, errmsg AS STRING) ' This one needs a callback function.
8.     FUNCTION Prepare% ALIAS sqlite3_prepare_v2 (Db AS _OFFSET, zSql AS STRING, nByte AS INTEGER, stmt AS _OFFSET, pzTail AS _OFFSET) ' instead of using sqlite3_exec() witch is a convenience wrapper, we can compile query statement using this funcion an then execute it using step(), this is the way Im going...
9. END DECLARE
10.  
11. '-------------------------------------------------------------------------------------------------------------------------------------------------
12.  
13. PRINT "Start DB engine"
14. PRINT ResultCode(StartSqlite)
15.  
16. DIM DbVar AS _UNSIGNED LONG
17. DIM Db AS _OFFSET
18. Db = _OFFSET(DbVar)
19.  
20. PRINT "Open DB"
21. PRINT ResultCode(OpenDb%("tst.db", Db))
22.  
23. DIM CPtr AS _UNSIGNED LONG
24. 'CPtr = _OFFSET(C)
25.  
26. DIM QueryStr AS STRING * 256
27. DIM QueryPtr AS _OFFSET
28. QueryStr = "CREATE TABLE Teste(Id Int, Nome Varchar)"
29. QueryPtr = _OFFSET(QueryStr)
30.  
31. DIM Stmt AS LONG
32. DIM Tail AS LONG
33.  
34. PRINT "Query preparation."
35. PRINT ResultCode(Prepare(Db, QueryStr, 256, QueryPtr, Tail))
36.  
37. PRINT "Close DB"
38. PRINT ResultCode(CloseDb%)  ' Here we should pass ppDb as a reference of the DB to be closed by sqlite3_close(), I´ve tryed LONG, _UNSIGNED LONG and _OFFSET but it still returns Sqlite3 Misuse, leaving empty returns OK
39.  
40. PRINT "Stop DB engine"
41. PRINT ResultCode(StopSqlite)
42.  
43. SLEEP 5
44.  
45.  
46.  
47.  
48. FUNCTION ResultCode$ (Code AS INTEGER)
49.  
50.     SELECT CASE Code
51.  
52.         CASE 0
53.             ResultCode$ = "SQLITE_OK"
54.         CASE 1
55.             ResultCode$ = "SQLITE_ERROR"
56.         CASE 2
57.             ResultCode$ = "SQLITE_INTERNAL"
58.         CASE 3
59.             ResultCode$ = "SQLITE_PERM"
60.         CASE 4
61.             ResultCode$ = "SQLITE_ABORT"
62.         CASE 5
63.             ResultCode$ = "SQLITE_BUSY"
64.         CASE 6
65.             ResultCode$ = "SQLITE_LOCKED"
66.         CASE 7
67.             ResultCode$ = "SQLITE_NOMEM"
68.         CASE 8
69.             ResultCode$ = "SQLITE_READONLY"
70.         CASE 9
71.             ResultCode$ = "SQLITE_INTERRUPT"
72.         CASE 10
73.             ResultCode$ = "SQLITE_IOERR"
74.         CASE 11
75.             ResultCode$ = "SQLITE_CORRUPT"
76.         CASE 12
77.             ResultCode$ = "SQLITE_NOTFOUND"
78.         CASE 13
79.             ResultCode$ = "SQLITE_FULL"
80.         CASE 14
81.             ResultCode$ = "SQLITE_CANTOPEN"
82.         CASE 15
83.             ResultCode$ = "SQLITE_PROTOCOL"
84.         CASE 16
85.             ResultCode$ = "SQLITE_EMPTY"
86.         CASE 17
87.             ResultCode$ = "SQLITE_SCHEMA"
88.         CASE 18
89.             ResultCode$ = "SQLITE_TOOBIG"
90.         CASE 19
91.             ResultCode$ = "SQLITE_CONSTRAINT"
92.         CASE 20
93.             ResultCode$ = "SQLITE_MISMATCH"
94.         CASE 21
95.             ResultCode$ = "SQLITE_MISUSE"
96.         CASE 22
97.             ResultCode$ = "SQLITE_NOLFS"
98.         CASE 23
99.             ResultCode$ = "SQLITE_AUTH"
100.         CASE 24
101.             ResultCode$ = "SQLITE_FORMAT"
102.         CASE 25
103.             ResultCode$ = "SQLITE_RANGE"
104.         CASE 26
105.             ResultCode$ = "SQLITE_NOTADB"
106.         CASE 27
107.             ResultCode$ = "SQLITE_NOTICE"
108.         CASE 28
109.             ResultCode$ = "SQLITE_WARNING"
110.         CASE 100
111.             ResultCode$ = "SQLITE_ROW"
112.         CASE 101
113.             ResultCode$ = "SQLITE_DONE"
114.  
115.     END SELECT
116.  
117. END FUNCTION
118.  

[TempodiBasic]

Hi KingRat
do you run for Halloween Challenge? https://www.qb64.org/forum/index.php?topic=694.0
It lasts only 4 days....

[TempodiBasic]

About your issue...

1. the error comes up from the

DIM QueryStr AS STRING * 256
DIM QueryPtr AS _OFFSET
QueryStr = "CREATE TABLE Teste(Id Int, Nome Varchar)"
QueryPtr = _OFFSET(QueryStr)

DIM Stmt AS LONG
DIM Tail AS LONG

PRINT "Query preparation."
PRINT ResultCode(Prepare(Db, QueryStr, 256, QueryPtr, Tail))

My feedback is limited because I don't know SQL.... but I see two issues
 1. has QueryStr a right SQL command into it?
 2. is possible to make a query with a void database?

About theory...https://www.sqlite.org/c3ref/prepare.html
we can focus on this

int sqlite3_prepare_v2(
  sqlite3 *db,            /* Database handle */
  const char *zSql,       /* SQL statement, UTF-8 encoded */
  int nByte,              /* Maximum length of zSql in bytes. */
  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
);

so I can understand that QueryStr must be a valid SQLStatement UTF-8 encoded....

but I need time to study.... https://www.sqlite.org/lang_createtable.html
So that is all for now...

[KingRat]

Hi Tempo!

Hi KingRat
do you run for Halloween Challenge? https://www.qb64.org/forum/index.php?topic=694.0
It lasts only 4 days....

No man! I´m not running. I think I´m not good enought to these kind of stuff... I mean, I´ll not bring anything new to the table...

1. has QueryStr a right SQL command into it?

Yes!
That query come from a query example I found at sqlite site.
And I´ve tryied both ways, sending the string offset QueryPtr and sending the string itself QueryStr.

2. is possible to make a query with a void database?

I think we can use a query into a void database to create tables (this is my for now) to start working with it.

Thanks again brother!

[TempodiBasic]

Tuning on the error
https://sqliteviewer.com/blog/how-to-fix-sqlite-error-code-21/

[KingRat]

Hi Folks!

Tuning on the error
https://sqliteviewer.com/blog/how-to-fix-sqlite-error-code-21/

The text still brings me to the sqlite3*, the same stuff I was trying to figure out...

Would it help to use a tool such as dllexp.exe from Nirsoft to view the exported functions? I think the tool can look into the DLL in further detail, perhaps the information you need can be extracted from using dllexp.exe or pelook.exe or some other DLL dumping tool?

Nice output you got, thanks! But the functions that the DLL exports isn´t the actual problem, aswe have the source code, but the way to deal with it in a QB64 code.
Cause qb64 dont support callback functions and que need to point to a sqlite3 struct....

Im still trying in my spare time, I need such a exercise to came back to programming and stuff and I think a sqlite3 will be a nice feature for this nice language..

Thanks!

[TempodiBasic]

Yes I agree
sqlite3 may be a nice addon for QB64.