• Vathix (7/7) Jul 29 2003 I need a database, I'm sure others will too. Does anyone know of one tha...
• Frank Wills (4/14) Jul 29 2003 You might take a look at www.sqlite.org It's an embeddable sql database
• Vathix (11/25) Jul 29 2003 that
• Frank Wills (7/48) Jul 29 2003 It's a great database engine. Light and good for
• Burton Radons (11/29) Jul 30 2003 That's a nice little library. The last one I tried to work with was
• Charles Sanders (145/796) Jul 30 2003 Sweet! Burton do you want to put these libraries up at atari-soldiers ?...
• Walter (4/11) Jul 29 2003 it.

"Vathix" <vathix dprogramming.com> writes:

I need a database, I'm sure others will too. Does anyone know of one that
could be easily used in D? I need it to be efficient and able to be fairly
large. I attempted to write my own, it failed. I got sick of my data
corrupting. I did learn from it, though.

If there are no existing databases for use with D, I'll try writing my own
again that anyone could use freely, but I'd like some tips and ideas for it.
What kind of interface would be best for it, etc.

Frank Wills <name host.com> writes:

Vathix wrote:
 I need a database, I'm sure others will too. Does anyone know of one that
 could be easily used in D? I need it to be efficient and able to be fairly
 large. I attempted to write my own, it failed. I got sick of my data
 corrupting. I did learn from it, though.
 
 If there are no existing databases for use with D, I'll try writing my own
 again that anyone could use freely, but I'd like some tips and ideas for it.
 What kind of interface would be best for it, etc.
 
 

You might take a look at www.sqlite.org It's an embeddable sql database
engine that I have used with C++, but have not yet figured out how to
use it directly with D. It may need an intermediate library in C.

"Vathix" <vathix dprogramming.com> writes:

"Frank Wills" <name host.com> wrote in message
news:bg757o$2t3r$1 digitaldaemon.com...
 Vathix wrote:
 I need a database, I'm sure others will too. Does anyone know of one


that
 could be easily used in D? I need it to be efficient and able to be


fairly
 large. I attempted to write my own, it failed. I got sick of my data
 corrupting. I did learn from it, though.

 If there are no existing databases for use with D, I'll try writing my


own
 again that anyone could use freely, but I'd like some tips and ideas for


it.
 What kind of interface would be best for it, etc.

 You might take a look at www.sqlite.org It's an embeddable sql database
 engine that I have used with C++, but have not yet figured out how to
 use it directly with D. It may need an intermediate library in C.

This is exactly what I want! I got it interfaced with D but I'm getting an
access violation when calling sqlite_open(). I compiled all the .c files
using dmc then I used lib to make sqlite.lib which should be usable with
dmd. Then I converted the main .h to a .d file, which contains all the
functions, constants, and structs needed.

Frank Wills <name host.com> writes:

It's a great database engine. Light and good for
application work.
Why don't you post your work when you get it working
with D? I'd like to take a look at it.
Thanks,
Frank.

Vathix wrote:
 "Frank Wills" <name host.com> wrote in message
 news:bg757o$2t3r$1 digitaldaemon.com...
 
Vathix wrote:

I need a database, I'm sure others will too. Does anyone know of one


 
 that
 
could be easily used in D? I need it to be efficient and able to be


 
 fairly
 
large. I attempted to write my own, it failed. I got sick of my data
corrupting. I did learn from it, though.

If there are no existing databases for use with D, I'll try writing my


 
 own
 
again that anyone could use freely, but I'd like some tips and ideas for


 
 it.
 
What kind of interface would be best for it, etc.

You might take a look at www.sqlite.org It's an embeddable sql database
engine that I have used with C++, but have not yet figured out how to
use it directly with D. It may need an intermediate library in C.

 
 
 This is exactly what I want! I got it interfaced with D but I'm getting an
 access violation when calling sqlite_open(). I compiled all the .c files
 using dmc then I used lib to make sqlite.lib which should be usable with
 dmd. Then I converted the main .h to a .d file, which contains all the
 functions, constants, and structs needed.
 
 

Burton Radons <loth users.sourceforge.net> writes:

Frank Wills wrote:

 Vathix wrote:
 
 I need a database, I'm sure others will too. Does anyone know of one that
 could be easily used in D? I need it to be efficient and able to be 
 fairly
 large. I attempted to write my own, it failed. I got sick of my data
 corrupting. I did learn from it, though.

 If there are no existing databases for use with D, I'll try writing my 
 own
 again that anyone could use freely, but I'd like some tips and ideas 
 for it.
 What kind of interface would be best for it, etc.

 You might take a look at www.sqlite.org It's an embeddable sql database
 engine that I have used with C++, but have not yet figured out how to
 use it directly with D. It may need an intermediate library in C.

That's a nice little library.  The last one I tried to work with was 
Berkeley's in Python, and that soured me so bad on small database 
libraries (the format wasn't portable between Windows and Linux!) that I 
didn't think there could be a useful one.

So I'm working on a wrapper for SQLite that uses the DLL and supplies a 
class, including little niceties like buffered table modifications.  A 
beta should be done in a couple of hours.

I've attached the import library and import headers for them.  You'll 
need the DLL from the SQLite site.  This should also work on the Linux 
side using the .so.

"Charles Sanders" <sanders-consulting comcast.net> writes:

Sweet!  Burton do you want to put these libraries up at atari-soldiers ?  I
was trying to find the archive library the other day but couldnt, maybe a
burtons page with links and libs ?

Charles


"Burton Radons" <loth users.sourceforge.net> wrote in message
news:bg8oab$1hgq$1 digitaldaemon.com...
 Frank Wills wrote:

 Vathix wrote:

 I need a database, I'm sure others will too. Does anyone know of one



that
 could be easily used in D? I need it to be efficient and able to be
 fairly
 large. I attempted to write my own, it failed. I got sick of my data
 corrupting. I did learn from it, though.

 If there are no existing databases for use with D, I'll try writing my
 own
 again that anyone could use freely, but I'd like some tips and ideas
 for it.
 What kind of interface would be best for it, etc.

 You might take a look at www.sqlite.org It's an embeddable sql database
 engine that I have used with C++, but have not yet figured out how to
 use it directly with D. It may need an intermediate library in C.

 That's a nice little library.  The last one I tried to work with was
 Berkeley's in Python, and that soured me so bad on small database
 libraries (the format wasn't portable between Windows and Linux!) that I
 didn't think there could be a useful one.

 So I'm working on a wrapper for SQLite that uses the DLL and supplies a
 class, including little niceties like buffered table modifications.  A
 beta should be done in a couple of hours.

 I've attached the import library and import headers for them.  You'll
 need the DLL from the SQLite site.  This should also work on the Linux
 side using the .so.


----------------------------------------------------------------------------
----


 module net.BurtonRadons.sqlite.sqlite_imp;

 /+
 #ifdef DOXYGEN_IS_A_PAIN
 +/

 extern (C)
 {
     /*
     ** Each open sqlite database is represented by an instance of the
     ** following opaque structure.
     */
     struct sqlite
     {
     }

     /*
     ** The type for a callback function.
     */
     alias int function (void*,int,char**, char**) sqlite_callback;

     /*
     ** A function to open a new sqlite database.
     **
     ** If the database does not exist and mode indicates write
     ** permission, then a new database is created.  If the database
     ** does not exist and mode does not indicate write permission,
     ** then the open fails, an error message generated (if errmsg!=0)
     ** and the function returns 0.
     **
     ** If mode does not indicates user write permission, then the
     ** database is opened read-only.
     **
     ** The Truth:  As currently implemented, all databases are opened
     ** for writing all the time.  Maybe someday we will provide the
     ** ability to open a database readonly.  The mode parameters is
     ** provided in anticipation of that enhancement.
     */
     sqlite *sqlite_open(char *filename, int mode, char **errmsg);

     /*
     ** A function to close the database.
     **
     ** Call this function with a pointer to a structure that was

previously
     ** returned from sqlite_open() and the corresponding database will by

closed.
     */
     void sqlite_close(sqlite *);

     /*
     ** A function to executes one or more statements of SQL.
     **
     ** If one or more of the SQL statements are queries, then
     ** the callback function specified by the 3rd parameter is
     ** invoked once for each row of the query result.  This callback
     ** should normally return 0.  If the callback returns a non-zero
     ** value then the query is aborted, all subsequent SQL statements
     ** are skipped and the sqlite_exec() function returns the

SQLITE_ABORT.
     **
     ** The 4th parameter is an arbitrary pointer that is passed
     ** to the callback function as its first parameter.
     **
     ** The 2nd parameter to the callback function is the number of
     ** columns in the query result.  The 3rd parameter to the callback
     ** is an array of strings holding the values for each column.
     ** The 4th parameter to the callback is an array of strings holding
     ** the names of each column.
     **
     ** The callback function may be NULL, even for queries.  A NULL
     ** callback is not an error.  It just means that no callback
     ** will be invoked.
     **
     ** If an error occurs while parsing or evaluating the SQL (but
     ** not while executing the callback) then an appropriate error
     ** message is written into memory obtained from malloc() and
     ** *errmsg is made to point to that message.  The calling function
     ** is responsible for freeing the memory that holds the error
     ** message.   Use sqlite_freemem() for this.  If errmsg==NULL,
     ** then no error message is ever written.
     **
     ** The return value is is SQLITE_OK if there are no errors and
     ** some other return code if there is an error.  The particular
     ** return value depends on the type of error.
     **
     ** If the query could not be executed because a database file is
     ** locked or busy, then this function returns SQLITE_BUSY.  (This
     ** behavior can be modified somewhat using the sqlite_busy_handler()
     ** and sqlite_busy_timeout() functions below.)
     */
     int sqlite_exec(
       sqlite*,                      /* An open database */
       char *sql,              /* SQL to be executed */
       sqlite_callback,              /* Callback function */
       void *,                       /* 1st argument to callback function

*/
       char **errmsg                 /* Error msg written here */
     );

     /*
     ** Return values for sqlite_exec() and sqlite_step()
     */
     const int SQLITE_OK = 0;   /* Successful result */
     const int SQLITE_ERROR = 1;   /* SQL error or missing database */
     const int SQLITE_INTERNAL = 2;   /* An internal logic error in SQLite

*/
     const int SQLITE_PERM = 3;   /* Access permission denied */
     const int SQLITE_ABORT = 4;   /* Callback routine requested an abort

*/
     const int SQLITE_BUSY = 5;   /* The database file is locked */
     const int SQLITE_LOCKED = 6;   /* A table in the database is locked */
     const int SQLITE_NOMEM = 7;   /* A malloc() failed */
     const int SQLITE_READONLY = 8;   /* Attempt to write a readonly

database */
     const int SQLITE_INTERRUPT = 9;   /* Operation terminated by

sqlite_interrupt() */
     const int SQLITE_IOERR = 10;   /* Some kind of disk I/O error occurred

*/
     const int SQLITE_CORRUPT = 11;   /* The database disk image is

malformed */
     const int SQLITE_NOTFOUND = 12;   /* (Internal Only) Table or record

not found */
     const int SQLITE_FULL = 13;   /* Insertion failed because database is

full */
     const int SQLITE_CANTOPEN = 14;   /* Unable to open the database file

*/
     const int SQLITE_PROTOCOL = 15;   /* Database lock protocol error */
     const int SQLITE_EMPTY = 16;   /* (Internal Only) Database table is

empty */
     const int SQLITE_SCHEMA = 17;   /* The database schema changed */
     const int SQLITE_TOOBIG = 18;   /* Too much data for one row of a

table */
     const int SQLITE_CONSTRAINT = 19;   /* Abort due to contraint

violation */
     const int SQLITE_MISMATCH = 20;   /* Data type mismatch */
     const int SQLITE_MISUSE = 21;   /* Library used incorrectly */
     const int SQLITE_NOLFS = 22;   /* Uses OS features not supported on

host */
     const int SQLITE_AUTH = 23;   /* Authorization denied */
     const int SQLITE_FORMAT = 24;   /* Auxiliary database format error */
     const int SQLITE_ROW = 100;  /* sqlite_step() has another row ready */
     const int SQLITE_DONE = 101;  /* sqlite_step() has finished executing

*/
     /*
     ** Each entry in an SQLite table has a unique integer key.  (The key

is
     ** the value of the INTEGER PRIMARY KEY column if there is such a

column,
     ** otherwise the key is generated at random.  The unique key is always
     ** available as the ROWID, OID, or _ROWID_ column.)  The following

routine
     ** returns the integer key of the most recent insert in the database.
     **
     ** This function is similar to the mysql_insert_id() function from

MySQL.
     */
     int sqlite_last_insert_rowid(sqlite*);

     /*
     ** This function returns the number of database rows that were changed
     ** (or inserted or deleted) by the most recent called sqlite_exec().
     **
     ** All changes are counted, even if they were later undone by a
     ** ROLLBACK or ABORT.  Except, changes associated with creating and
     ** dropping tables are not counted.
     **
     ** If a callback invokes sqlite_exec() recursively, then the changes
     ** in the inner, recursive call are counted together with the changes
     ** in the outer call.
     **
     ** SQLite implements the command "DELETE FROM table" without a WHERE

clause
     ** by dropping and recreating the table.  (This is much faster than

going
     ** through and deleting individual elements form the table.)  Because

of
     ** this optimization, the change count for "DELETE FROM table" will be
     ** zero regardless of the number of elements that were originally in

the
     ** table. To get an accurate count of the number of rows deleted, use
     ** "DELETE FROM table WHERE 1" instead.
     */
     int sqlite_changes(sqlite*);

     /* If the parameter to this routine is one of the return value

constants
     ** defined above, then this routine returns a constant text string

which
     ** descripts (in English) the meaning of the return value.
     */
     char *sqlite_error_string(int);

     /* This function causes any pending database operation to abort and
     ** return at its earliest opportunity.  This routine is typically
     ** called in response to a user action such as pressing "Cancel"
     ** or Ctrl-C where the user wants a long query operation to halt
     ** immediately.
     */
     void sqlite_interrupt(sqlite*);


     /* This function returns true if the given input string comprises
     ** one or more complete SQL statements.
     **
     ** The algorithm is simple.  If the last token other than spaces
     ** and comments is a semicolon, then return true.  otherwise return
     ** false.
     */
     int sqlite_complete(char *sql);

     /*
     ** This routine identifies a callback function that is invoked
     ** whenever an attempt is made to open a database table that is
     ** currently locked by another process or thread.  If the busy

callback
     ** is NULL, then sqlite_exec() returns SQLITE_BUSY immediately if
     ** it finds a locked table.  If the busy callback is not NULL, then
     ** sqlite_exec() invokes the callback with three arguments.  The
     ** second argument is the name of the locked table and the third
     ** argument is the number of times the table has been busy.  If the
     ** busy callback returns 0, then sqlite_exec() immediately returns
     ** SQLITE_BUSY.  If the callback returns non-zero, then sqlite_exec()
     ** tries to open the table again and the cycle repeats.
     **
     ** The default busy callback is NULL.
     **
     ** Sqlite is re-entrant, so the busy handler may start a new query.
     ** (It is not clear why anyone would every want to do this, but it
     ** is allowed, in theory.)  But the busy handler may not close the
     ** database.  Closing the database from a busy handler will delete
     ** data structures out from under the executing query and will
     ** probably result in a coredump.
     */
     void sqlite_busy_handler(sqlite*, int(*)(void*, char*,int), void*);

     /*
     ** This routine sets a busy handler that sleeps for a while when a
     ** table is locked.  The handler will sleep multiple times until
     ** at least "ms" milleseconds of sleeping have been done.  After
     ** "ms" milleseconds of sleeping, the handler returns 0 which
     ** causes sqlite_exec() to return SQLITE_BUSY.
     **
     ** Calling this routine with an argument less than or equal to zero
     ** turns off all busy handlers.
     */
     void sqlite_busy_timeout(sqlite*, int ms);

     /*
     ** This next routine is really just a wrapper around sqlite_exec().
     ** Instead of invoking a user-supplied callback for each row of the
     ** result, this routine remembers each row of the result in memory
     ** obtained from malloc(), then returns all of the result after the
     ** query has finished.
     **
     ** As an example, suppose the query result where this table:
     **
     **        Name        | Age
     **        -----------------------
     **        Alice       | 43
     **        Bob         | 28
     **        Cindy       | 21
     **
     ** If the 3rd argument were &azResult then after the function returns
     ** azResult will contain the following data:
     **
     **        azResult[0] = "Name";
     **        azResult[1] = "Age";
     **        azResult[2] = "Alice";
     **        azResult[3] = "43";
     **        azResult[4] = "Bob";
     **        azResult[5] = "28";
     **        azResult[6] = "Cindy";
     **        azResult[7] = "21";
     **
     ** Notice that there is an extra row of data containing the column
     ** headers.  But the *nrow return value is still 3.  *ncolumn is
     ** set to 2.  In general, the number of values inserted into azResult
     ** will be ((*nrow) + 1)*(*ncolumn).
     **
     ** After the calling function has finished using the result, it should
     ** pass the result data pointer to sqlite_free_table() in order to
     ** release the memory that was malloc-ed.  Because of the way the
     ** malloc() happens, the calling function must not try to call
     ** malloc() directly.  Only sqlite_free_table() is able to release
     ** the memory properly and safely.
     **
     ** The return value of this routine is the same as from sqlite_exec().
     */
     int sqlite_get_table(
       sqlite*,               /* An open database */
       char *sql,       /* SQL to be executed */
       char ***resultp,       /* Result written to a char *[]  that this

points to */
       int *nrow,             /* Number of result rows written here */
       int *ncolumn,          /* Number of result columns written here */
       char **errmsg          /* Error msg written here */
     );

     /*
     ** Call this routine to free the memory that sqlite_get_table()

allocated.
     */
     void sqlite_free_table(char **result);

     /*
     ** The following routines are wrappers around sqlite_exec() and
     ** sqlite_get_table().  The only difference between the routines that
     ** follow and the originals is that the second argument to the
     ** routines that follow is really a printf()-style format
     ** string describing the SQL to be executed.  Arguments to the format
     ** string appear at the end of the argument list.
     **
     ** All of the usual printf formatting options apply.  In addition,

there
     ** is a "%q" option.  %q works like %s in that it substitutes a

null-terminated
     ** string from the argument list.  But %q also doubles every '\''

character.
     ** %q is designed for use inside a string literal.  By doubling each

'\''
     ** character it escapes that character and allows it to be inserted

into
     ** the string.
     **
     ** For example, so some string variable contains text as follows:
     **
     **      char *zText = "It's a happy day!";
     **
     ** We can use this text in an SQL statement as follows:
     **
     **      sqlite_exec_printf(db, "INSERT INTO table VALUES('%q')",
     **          callback1, 0, 0, zText);
     **
     ** Because the %q format string is used, the '\'' character in zText
     ** is escaped and the SQL generated is as follows:
     **
     **      INSERT INTO table1 VALUES('It''s a happy day!')
     **
     ** This is correct.  Had we used %s instead of %q, the generated SQL
     ** would have looked like this:
     **
     **      INSERT INTO table1 VALUES('It's a happy day!');
     **
     ** This second example is an SQL syntax error.  As a general rule you
     ** should always use %q instead of %s when inserting text into a

string
     ** literal.
     */
     int sqlite_exec_printf(
       sqlite*,                      /* An open database */
       char *sqlFormat,        /* printf-style format string for the SQL */
       sqlite_callback,              /* Callback function */
       void *,                       /* 1st argument to callback function

*/
       char **errmsg,                /* Error msg written here */
       ...                           /* Arguments to the format string. */
     );

     int sqlite_exec_vprintf(
       sqlite*,                      /* An open database */
       char *sqlFormat,        /* printf-style format string for the SQL */
       sqlite_callback,              /* Callback function */
       void *,                       /* 1st argument to callback function

*/
       char **errmsg,                /* Error msg written here */
       va_list ap                    /* Arguments to the format string. */
     );

     int sqlite_get_table_printf(
       sqlite*,               /* An open database */
       char *sqlFormat, /* printf-style format string for the SQL */
       char ***resultp,       /* Result written to a char *[]  that this

points to */
       int *nrow,             /* Number of result rows written here */
       int *ncolumn,          /* Number of result columns written here */
       char **errmsg,         /* Error msg written here */
       ...                    /* Arguments to the format string */
     );

     int sqlite_get_table_vprintf(
       sqlite*,               /* An open database */
       char *sqlFormat, /* printf-style format string for the SQL */
       char ***resultp,       /* Result written to a char *[]  that this

points to */
       int *nrow,             /* Number of result rows written here */
       int *ncolumn,          /* Number of result columns written here */
       char **errmsg,         /* Error msg written here */
       va_list ap             /* Arguments to the format string */
     );

     char *sqlite_mprintf(char*,...);
     char *sqlite_vmprintf(char*, va_list);

     /*
     ** Windows systems should call this routine to free memory that
     ** is returned in the in the errmsg parameter of sqlite_open() when
     ** SQLite is a DLL.  For some reason, it does not work to call free()
     ** directly.
     */
     void sqlite_freemem(void *p);

     /*
     ** Windows systems need functions to call to return the sqlite_version
     ** and sqlite_encoding strings.
     */
     char *sqlite_libversion();
     char *sqlite_libencoding();

     /*
     ** A pointer to the following structure is used to communicate with
     ** the implementations of user-defined functions.
     */
     struct sqlite_func { }

     /*
     ** Use the following routines to create new user-defined functions.

See
     ** the documentation for details.
     */
     int sqlite_create_function(
       sqlite*,                  /* Database where the new function is

registered */
       char *zName,        /* Name of the new function */
       int nArg,                 /* Number of arguments.  -1 means any

number */
       void (*xFunc)(sqlite_func*,int, char**),  /* C code to implement */
       void *pUserData           /* Available via the sqlite_user_data()

call */
     );

     int sqlite_create_aggregate(
       sqlite*,                  /* Database where the new function is

registered */
       char *zName,        /* Name of the function */
       int nArg,                 /* Number of arguments */
       void (*xStep)(sqlite_func*,int, char**), /* Called for each row */
       void (*xFinalize)(sqlite_func*),       /* Called once to get final

result */
       void *pUserData           /* Available via the sqlite_user_data()

call */
     );

     /*
     ** Use the following routine to define the datatype returned by a
     ** user-defined function.  The second argument can be one of the
     ** constants SQLITE_NUMERIC, SQLITE_TEXT, or SQLITE_ARGS or it
     ** can be an integer greater than or equal to zero.  The datatype
     ** will be numeric or text (the only two types supported) if the
     ** argument is SQLITE_NUMERIC or SQLITE_TEXT.  If the argument is
     ** SQLITE_ARGS, then the datatype is numeric if any argument to the
     ** function is numeric and is text otherwise.  If the second argument
     ** is an integer, then the datatype of the result is the same as the
     ** parameter to the function that corresponds to that integer.
     */
     int sqlite_function_type(
       sqlite *db,               /* The database there the function is

registered */
       char *zName,        /* Name of the function */
       int datatype              /* The datatype for this function */
     );

     const int SQLITE_NUMERIC = (-1);
     const int SQLITE_TEXT = (-2);
     const int SQLITE_ARGS = (-3);

     /*
     ** The user function implementations call one of the following four

routines
     ** in order to return their results.  The first parameter to each of

these
     ** routines is a copy of the first argument to xFunc() or

xFinialize().
     ** The second parameter to these routines is the result to be

returned.
     ** A NULL can be passed as the second parameter to

sqlite_set_result_string()
     ** in order to return a NULL result.
     **
     ** The 3rd argument to _string and _error is the number of characters

to
     ** take from the string.  If this argument is negative, then all

characters
     ** up to and including the first '\000' are used.
     **
     ** The sqlite_set_result_string() function allocates a buffer to hold

the
     ** result and returns a pointer to this buffer.  The calling routine
     ** (that is, the implmentation of a user function) can alter the

content
     ** of this buffer if desired.
     */
     char *sqlite_set_result_string(sqlite_func*, char*,int);
     void sqlite_set_result_int(sqlite_func*,int);
     void sqlite_set_result_double(sqlite_func*,double);
     void sqlite_set_result_error(sqlite_func*, char*,int);

     /*
     ** The pUserData parameter to the sqlite_create_function() and
     ** sqlite_create_aggregate() routines used to register user functions
     ** is available to the implementation of the function using this
     ** call.
     */
     void *sqlite_user_data(sqlite_func*);

     /*
     ** Aggregate functions use the following routine to allocate
     ** a structure for storing their state.  The first time this routine
     ** is called for a particular aggregate, a new structure of size

nBytes
     ** is allocated, zeroed, and returned.  On subsequent calls (for the
     ** same aggregate instance) the same buffer is returned.  The

implementation
     ** of the aggregate can use the returned buffer to accumulate data.
     **
     ** The buffer allocated is freed automatically be SQLite.
     */
     void *sqlite_aggregate_context(sqlite_func*, int nBytes);

     /*
     ** The next routine returns the number of calls to xStep for a

particular
     ** aggregate function instance.  The current call to xStep counts so

this
     ** routine always returns at least 1.
     */
     int sqlite_aggregate_count(sqlite_func*);

     /*
     ** This routine registers a callback with the SQLite library.  The
     ** callback is invoked (at compile-time, not at run-time) for each
     ** attempt to access a column of a table in the database.  The

callback
     ** returns SQLITE_OK if access is allowed, SQLITE_DENY if the entire
     ** SQL statement should be aborted with an error and SQLITE_IGNORE
     ** if the column should be treated as a NULL value.
     */
     int sqlite_set_authorizer(
       sqlite*,
       int (*xAuth)(void*,int, char*, char*, char*, char*),
       void *pUserData
     );

     /*
     ** The second parameter to the access authorization function above

will
     ** be one of the values below.  These values signify what kind of

operation
     ** is to be authorized.  The 3rd and 4th parameters to the

authorization
     ** function will be parameters or NULL depending on which of the

following
     ** codes is used as the second parameter.  The 5th parameter is the

name
     ** of the database ("main", "temp", etc.) if applicable.  The 6th

parameter
     ** is the name of the inner-most trigger or view that is responsible

for
     ** the access attempt or NULL if this access attempt is directly from
     ** input SQL code.
     **
     **                                          Arg-3           Arg-4
     */
     const int SQLITE_COPY = 0;   /* Table Name      File Name       */
     const int SQLITE_CREATE_INDEX = 1;   /* Index Name      Table Name

*/
     const int SQLITE_CREATE_TABLE = 2;   /* Table Name      NULL

*/
     const int SQLITE_CREATE_TEMP_INDEX = 3;   /* Index Name      Table

Name      */
     const int SQLITE_CREATE_TEMP_TABLE = 4;   /* Table Name      NULL

*/
     const int SQLITE_CREATE_TEMP_TRIGGER = 5;   /* Trigger Name    Table

Name      */
     const int SQLITE_CREATE_TEMP_VIEW = 6;   /* View Name       NULL

*/
     const int SQLITE_CREATE_TRIGGER = 7;   /* Trigger Name    Table Name

*/
     const int SQLITE_CREATE_VIEW = 8;   /* View Name       NULL

*/
     const int SQLITE_DELETE = 9;   /* Table Name      NULL            */
     const int SQLITE_DROP_INDEX = 10;   /* Index Name      Table Name

*/
     const int SQLITE_DROP_TABLE = 11;   /* Table Name      NULL

*/
     const int SQLITE_DROP_TEMP_INDEX = 12;   /* Index Name      Table Name

*/
     const int SQLITE_DROP_TEMP_TABLE = 13;   /* Table Name      NULL

*/
     const int SQLITE_DROP_TEMP_TRIGGER = 14;   /* Trigger Name    Table

Name      */
     const int SQLITE_DROP_TEMP_VIEW = 15;   /* View Name       NULL

*/
     const int SQLITE_DROP_TRIGGER = 16;   /* Trigger Name    Table Name

*/
     const int SQLITE_DROP_VIEW = 17;   /* View Name       NULL

*/
     const int SQLITE_INSERT = 18;   /* Table Name      NULL            */
     const int SQLITE_PRAGMA = 19;   /* Pragma Name     1st arg or NULL */
     const int SQLITE_READ = 20;   /* Table Name      Column Name     */
     const int SQLITE_SELECT = 21;   /* NULL            NULL            */
     const int SQLITE_TRANSACTION = 22;   /* NULL            NULL

*/
     const int SQLITE_UPDATE = 23;   /* Table Name      Column Name     */
     const int SQLITE_ATTACH = 24;   /* Filename        NULL            */
     const int SQLITE_DETACH = 25;   /* Database Name   NULL            */


     /*
     ** The return value of the authorization function should be one of the
     ** following constants:
     */
     /* const int SQLITE_OK = 0;   // Allow access (This is actually

defined above) */
     const int SQLITE_DENY = 1;   /* Abort the SQL statement with an error

*/
     const int SQLITE_IGNORE = 2;   /* Don't allow access, but don't

generate an error */
     /*
     ** Register a function that is called at every invocation of

sqlite_exec()
     ** or sqlite_compile().  This function can be used (for example) to

generate
     ** a log file of all SQL executed against a database.
     */
     void *sqlite_trace(sqlite*, void(*xTrace)(void*, char*), void*);

     /*** The Callback-Free API
     **
     ** The following routines implement a new way to access SQLite that

does not
     ** involve the use of callbacks.
     **
     ** An sqlite_vm is an opaque object that represents a single SQL

statement
     ** that is ready to be executed.
     */
     struct sqlite_vm { }

     /*
     ** To execute an SQLite query without the use of callbacks, you first

have
     ** to compile the SQL using this routine.  The 1st parameter "db" is a

pointer
     ** to an sqlite object obtained from sqlite_open().  The 2nd parameter
     ** "zSql" is the text of the SQL to be compiled.   The remaining

parameters
     ** are all outputs.
     **
     ** *pzTail is made to point to the first character past the end of the

first
     ** SQL statement in zSql.  This routine only compiles the first

statement
     ** in zSql, so *pzTail is left pointing to what remains uncompiled.
     **
     ** *ppVm is left pointing to a "virtual machine" that can be used to

execute
     ** the compiled statement.  Or if there is an error, *ppVm may be set

to NULL.
     ** If the input text contained no SQL (if the input is and empty

string or
     ** a comment) then *ppVm is set to NULL.
     **
     ** If any errors are detected during compilation, an error message is

written
     ** into space obtained from malloc() and *pzErrMsg is made to point to

that
     ** error message.  The calling routine is responsible for freeing the

text
     ** of this message when it has finished with it.  Use sqlite_freemem()

to
     ** free the message.  pzErrMsg may be NULL in which case no error

message
     ** will be generated.
     **
     ** On success, SQLITE_OK is returned.  Otherwise and error code is

returned.
     */
     int sqlite_compile(
       sqlite *db,                   /* The open database */
       char *zSql,             /* SQL statement to be compiled */
       char **pzTail,          /* OUT: uncompiled tail of zSql */
       sqlite_vm **ppVm,             /* OUT: the virtual machine to execute

zSql */
       char **pzErrmsg               /* OUT: Error message. */
     );

     /*
     ** After an SQL statement has been compiled, it is handed to this

routine
     ** to be executed.  This routine executes the statement as far as it

can
     ** go then returns.  The return value will be one of SQLITE_DONE,
     ** SQLITE_ERROR, SQLITE_BUSY, SQLITE_ROW, or SQLITE_MISUSE.
     **
     ** SQLITE_DONE means that the execute of the SQL statement is complete
     ** an no errors have occurred.  sqlite_step() should not be called

again
     ** for the same virtual machine.  *pN is set to the number of columns

in
     ** the result set and *pazColName is set to an array of strings that
     ** describe the column names and datatypes.  The name of the i-th

column
     ** is (*pazColName)[i] and the datatype of the i-th column is
     ** (*pazColName)[i+*pN].  *pazValue is set to NULL.
     **
     ** SQLITE_ERROR means that the virtual machine encountered a run-time
     ** error.  sqlite_step() should not be called again for the same
     ** virtual machine.  *pN is set to 0 and *pazColName and *pazValue are

set
     ** to NULL.  Use sqlite_finalize() to obtain the specific error code
     ** and the error message text for the error.
     **
     ** SQLITE_BUSY means that an attempt to open the database failed

because
     ** another thread or process is holding a lock.  The calling routine
     ** can try again to open the database by calling sqlite_step() again.
     ** The return code will only be SQLITE_BUSY if no busy handler is

registered
     ** using the sqlite_busy_handler() or sqlite_busy_timeout() routines.

If
     ** a busy handler callback has been registered but returns 0, then

this
     ** routine will return SQLITE_ERROR and sqltie_finalize() will return
     ** SQLITE_BUSY when it is called.
     **
     ** SQLITE_ROW means that a single row of the result is now available.
     ** The data is contained in *pazValue.  The value of the i-th column

is
     ** (*azValue)[i].  *pN and *pazColName are set as described in

SQLITE_DONE.
     ** Invoke sqlite_step() again to advance to the next row.
     **
     ** SQLITE_MISUSE is returned if sqlite_step() is called incorrectly.
     ** For example, if you call sqlite_step() after the virtual machine
     ** has halted (after a prior call to sqlite_step() has returned

SQLITE_DONE)
     ** or if you call sqlite_step() with an incorrectly initialized

virtual
     ** machine or a virtual machine that has been deleted or that is

associated
     ** with an sqlite structure that has been closed.
     */
     int sqlite_step(
       sqlite_vm *pVm,              /* The virtual machine to execute */
       int *pN,                     /* OUT: Number of columns in result */
       char ***pazValue,      /* OUT: Column data */
       char ***pazColName     /* OUT: Column names and datatypes */
     );

     /*
     ** This routine is called to delete a virtual machine after it has

finished
     ** executing.  The return value is the result code.  SQLITE_OK is

returned
     ** if the statement executed successfully and some other value is

returned if
     ** there was any kind of error.  If an error occurred and pzErrMsg is

not
     ** NULL, then an error message is written into memory obtained from

malloc()
     ** and *pzErrMsg is made to point to that error message.  The calling

routine
     ** should use sqlite_freemem() to delete this message when it has

finished
     ** with it.
     **
     ** This routine can be called at any point during the execution of the
     ** virtual machine.  If the virtual machine has not completed

execution
     ** when this routine is called, that is like encountering an error or
     ** an interrupt.  (See sqlite_interrupt().)  Incomplete updates may be
     ** rolled back and transactions cancelled,  depending on the

circumstances,
     ** and the result code returned will be SQLITE_ABORT.
     */
     int sqlite_finalize(sqlite_vm*, char **pzErrMsg);

     /*
     ** This routine deletes the virtual machine, writes any error message

to
     ** *pzErrMsg and returns an SQLite return code in the same way as the
     ** sqlite_finalize() function.
     **
     ** Additionally, if ppVm is not NULL, *ppVm is left pointing to a new

virtual
     ** machine loaded with the compiled version of the original query

ready for
     ** execution.
     **
     ** If sqlite_reset() returns SQLITE_SCHEMA, then *ppVm is set to NULL.
     **
     ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
     */
     int sqlite_reset(sqlite_vm *, char **pzErrMsg, sqlite_vm **ppVm);
 }

 /+
 #endif
 +/

"Walter" <walter digitalmars.com> writes:

"Vathix" <vathix dprogramming.com> wrote in message
news:bg73jg$2rka$1 digitaldaemon.com...
 I need a database, I'm sure others will too. Does anyone know of one that
 could be easily used in D? I need it to be efficient and able to be fairly
 large. I attempted to write my own, it failed. I got sick of my data
 corrupting. I did learn from it, though.

 If there are no existing databases for use with D, I'll try writing my own
 again that anyone could use freely, but I'd like some tips and ideas for

it.
 What kind of interface would be best for it, etc.

You can use any one with a C interface.