diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/md5.c | 10 | ||||
| -rw-r--r-- | src/os.c | 18 | ||||
| -rw-r--r-- | src/pager.c | 6 | ||||
| -rw-r--r-- | src/printf.c | 32 | ||||
| -rw-r--r-- | src/select.c | 6 | ||||
| -rw-r--r-- | src/shell.c | 62 | ||||
| -rw-r--r-- | src/sqlite.h.in | 218 | ||||
| -rw-r--r-- | src/sqliteInt.h | 14 | ||||
| -rw-r--r-- | src/table.c | 28 | ||||
| -rw-r--r-- | src/tclsqlite.c | 72 | ||||
| -rw-r--r-- | src/test1.c | 220 | ||||
| -rw-r--r-- | src/test2.c | 8 | ||||
| -rw-r--r-- | src/test4.c | 22 | ||||
| -rw-r--r-- | src/tokenize.c | 10 | ||||
| -rw-r--r-- | src/trigger.c | 10 | ||||
| -rw-r--r-- | src/update.c | 4 | ||||
| -rw-r--r-- | src/util.c | 42 | ||||
| -rw-r--r-- | src/vacuum.c | 24 | ||||
| -rw-r--r-- | src/vdbe.c | 62 |
19 files changed, 434 insertions, 434 deletions
@@ -360,9 +360,9 @@ static void md5step(sqlite_func *context, int argc, const char **argv){ MD5Context *p; int i; if( argc<1 ) return; - p = sqlite_aggregate_context(context, sizeof(*p)); + p = sqlite3_aggregate_context(context, sizeof(*p)); if( p==0 ) return; - if( sqlite_aggregate_count(context)==1 ){ + if( sqlite3_aggregate_count(context)==1 ){ MD5Init(p); } for(i=0; i<argc; i++){ @@ -375,13 +375,13 @@ static void md5finalize(sqlite_func *context){ MD5Context *p; unsigned char digest[16]; char zBuf[33]; - p = sqlite_aggregate_context(context, sizeof(*p)); + p = sqlite3_aggregate_context(context, sizeof(*p)); MD5Final(digest,p); DigestToBase16(digest, zBuf); - sqlite_set_result_string(context, zBuf, strlen(zBuf)); + sqlite3_set_result_string(context, zBuf, strlen(zBuf)); } void Md5_Register(sqlite *db){ - sqlite_create_aggregate(db, "md5sum", -1, md5step, md5finalize, 0); + sqlite3_create_aggregate(db, "md5sum", -1, md5step, md5finalize, 0); } @@ -362,12 +362,12 @@ int findLockInfo( ** is used for testing the I/O recovery logic. */ #ifdef SQLITE_TEST -int sqlite_io_error_pending = 0; +int sqlite3_io_error_pending = 0; #define SimulateIOError(A) \ - if( sqlite_io_error_pending ) \ - if( sqlite_io_error_pending-- == 1 ){ local_ioerr(); return A; } + if( sqlite3_io_error_pending ) \ + if( sqlite3_io_error_pending-- == 1 ){ local_ioerr(); return A; } static void local_ioerr(){ - sqlite_io_error_pending = 0; /* Really just a place to set a breakpoint */ + sqlite3_io_error_pending = 0; /* Really just a place to set a breakpoint */ } #else #define SimulateIOError(A) @@ -377,8 +377,8 @@ static void local_ioerr(){ ** When testing, keep a count of the number of open files. */ #ifdef SQLITE_TEST -int sqlite_open_file_count = 0; -#define OpenCounter(X) sqlite_open_file_count+=(X) +int sqlite3_open_file_count = 0; +#define OpenCounter(X) sqlite3_open_file_count+=(X) #else #define OpenCounter(X) #endif @@ -1785,7 +1785,7 @@ char *sqlite3OsFullPathname(const char *zRelative){ ** returned from sqlite3OsCurrentTime(). This is used for testing. */ #ifdef SQLITE_TEST -int sqlite_current_time = 0; +int sqlite3_current_time = 0; #endif /* @@ -1810,8 +1810,8 @@ int sqlite3OsCurrentTime(double *prNow){ *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5; #endif #ifdef SQLITE_TEST - if( sqlite_current_time ){ - *prNow = sqlite_current_time/86400.0 + 2440587.5; + if( sqlite3_current_time ){ + *prNow = sqlite3_current_time/86400.0 + 2440587.5; } #endif return 0; diff --git a/src/pager.c b/src/pager.c index f8c7ba06f..e098aeafe 100644 --- a/src/pager.c +++ b/src/pager.c @@ -18,7 +18,7 @@ ** file simultaneously, or one process from reading the database while ** another is writing. ** -** @(#) $Id: pager.c,v 1.105 2004/05/08 20:07:40 drh Exp $ +** @(#) $Id: pager.c,v 1.106 2004/05/10 10:34:49 danielk1977 Exp $ */ #include "os.h" /* Must be first to enable large file support */ #include "sqliteInt.h" @@ -932,7 +932,7 @@ int sqlite3pager_open( char zTemp[SQLITE_TEMPNAME_SIZE]; *ppPager = 0; - if( sqlite_malloc_failed ){ + if( sqlite3_malloc_failed ){ return SQLITE_NOMEM; } if( zFilename && zFilename[0] ){ @@ -945,7 +945,7 @@ int sqlite3pager_open( zFullPathname = sqlite3OsFullPathname(zFilename); tempFile = 1; } - if( sqlite_malloc_failed ){ + if( sqlite3_malloc_failed ){ return SQLITE_NOMEM; } if( rc!=SQLITE_OK ){ diff --git a/src/printf.c b/src/printf.c index 6aee66d21..bce1770b7 100644 --- a/src/printf.c +++ b/src/printf.c @@ -753,7 +753,7 @@ char *sqlite3MPrintf(const char *zFormat, ...){ ** Print into memory obtained from malloc(). Do not use the internal ** %-conversion extensions. This routine is for use by external users. */ -char *sqlite_mprintf(const char *zFormat, ...){ +char *sqlite3_mprintf(const char *zFormat, ...){ va_list ap; char *z; char zBuf[200]; @@ -765,21 +765,21 @@ char *sqlite_mprintf(const char *zFormat, ...){ return z; } -/* This is the varargs version of sqlite_mprintf. +/* This is the varargs version of sqlite3_mprintf. */ -char *sqlite_vmprintf(const char *zFormat, va_list ap){ +char *sqlite3_vmprintf(const char *zFormat, va_list ap){ char zBuf[200]; return base_vprintf((void*(*)(void*,int))realloc, 0, zBuf, sizeof(zBuf), zFormat, ap); } /* -** sqlite_snprintf() works like snprintf() except that it ignores the +** sqlite3_snprintf() works like snprintf() except that it ignores the ** current locale settings. This is important for SQLite because we ** are not able to use a "," as the decimal point in place of "." as ** specified by some locales. */ -char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){ +char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){ char *z; va_list ap; @@ -791,13 +791,13 @@ char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){ /* ** The following four routines implement the varargs versions of the -** sqlite_exec() and sqlite_get_table() interfaces. See the sqlite.h +** sqlite3_exec() and sqlite3_get_table() interfaces. See the sqlite.h ** header files for a more detailed description of how these interfaces ** work. ** ** These routines are all just simple wrappers. */ -int sqlite_exec_printf( +int sqlite3_exec_printf( sqlite *db, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ sqlite_callback xCallback, /* Callback function */ @@ -809,11 +809,11 @@ int sqlite_exec_printf( int rc; va_start(ap, errmsg); - rc = sqlite_exec_vprintf(db, sqlFormat, xCallback, pArg, errmsg, ap); + rc = sqlite3_exec_vprintf(db, sqlFormat, xCallback, pArg, errmsg, ap); va_end(ap); return rc; } -int sqlite_exec_vprintf( +int sqlite3_exec_vprintf( sqlite *db, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ sqlite_callback xCallback, /* Callback function */ @@ -824,12 +824,12 @@ int sqlite_exec_vprintf( char *zSql; int rc; - zSql = sqlite_vmprintf(sqlFormat, ap); - rc = sqlite_exec(db, zSql, xCallback, pArg, errmsg); + zSql = sqlite3_vmprintf(sqlFormat, ap); + rc = sqlite3_exec(db, zSql, xCallback, pArg, errmsg); free(zSql); return rc; } -int sqlite_get_table_printf( +int sqlite3_get_table_printf( sqlite *db, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ char ***resultp, /* Result written to a char *[] that this points to */ @@ -842,11 +842,11 @@ int sqlite_get_table_printf( int rc; va_start(ap, errmsg); - rc = sqlite_get_table_vprintf(db, sqlFormat, resultp, nrow, ncol, errmsg, ap); + rc = sqlite3_get_table_vprintf(db, sqlFormat, resultp, nrow, ncol, errmsg, ap); va_end(ap); return rc; } -int sqlite_get_table_vprintf( +int sqlite3_get_table_vprintf( sqlite *db, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ char ***resultp, /* Result written to a char *[] that this points to */ @@ -858,8 +858,8 @@ int sqlite_get_table_vprintf( char *zSql; int rc; - zSql = sqlite_vmprintf(sqlFormat, ap); - rc = sqlite_get_table(db, zSql, resultp, nrow, ncolumn, errmsg); + zSql = sqlite3_vmprintf(sqlFormat, ap); + rc = sqlite3_get_table(db, zSql, resultp, nrow, ncolumn, errmsg); free(zSql); return rc; } diff --git a/src/select.c b/src/select.c index bd3d7ae51..e913d5dee 100644 --- a/src/select.c +++ b/src/select.c @@ -12,7 +12,7 @@ ** This file contains C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** -** $Id: select.c,v 1.162 2004/05/08 08:23:32 danielk1977 Exp $ +** $Id: select.c,v 1.163 2004/05/10 10:34:49 danielk1977 Exp $ */ #include "sqliteInt.h" @@ -692,7 +692,7 @@ static void generateColumnNames( int fullNames, shortNames; assert( v!=0 ); - if( pParse->colNamesSet || v==0 || sqlite_malloc_failed ) return; + if( pParse->colNamesSet || v==0 || sqlite3_malloc_failed ) return; pParse->colNamesSet = 1; fullNames = (db->flags & SQLITE_FullColNames)!=0; shortNames = (db->flags & SQLITE_ShortColNames)!=0; @@ -2007,7 +2007,7 @@ int sqlite3Select( int distinct; /* Table to use for the distinct set */ int rc = 1; /* Value to return from this function */ - if( sqlite_malloc_failed || pParse->nErr || p==0 ) return 1; + if( sqlite3_malloc_failed || pParse->nErr || p==0 ) return 1; if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; /* If there is are a sequence of queries, do the earlier ones first. diff --git a/src/shell.c b/src/shell.c index 08ba508df..648a9bbec 100644 --- a/src/shell.c +++ b/src/shell.c @@ -12,7 +12,7 @@ ** This file contains code to implement the "sqlite" command line ** utility for accessing SQLite databases. ** -** $Id: shell.c,v 1.94 2004/05/08 08:23:32 danielk1977 Exp $ +** $Id: shell.c,v 1.95 2004/05/10 10:34:52 danielk1977 Exp $ */ #include <stdlib.h> #include <string.h> @@ -271,7 +271,7 @@ static void output_html_string(FILE *out, const char *z){ */ static void interrupt_handler(int NotUsed){ seenInterrupt = 1; - if( db ) sqlite_interrupt(db); + if( db ) sqlite3_interrupt(db); } /* @@ -460,7 +460,7 @@ static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){ d2.mode = MODE_Insert; d2.zDestTable = 0; set_table_name(&d2, azArg[0]); - sqlite_exec_printf(p->db, + sqlite3_exec_printf(p->db, "SELECT * FROM '%q'", callback, &d2, 0, azArg[0] ); @@ -513,9 +513,9 @@ static void open_db(struct callback_data *p){ char *zErrMsg = 0; #ifdef SQLITE_HAS_CODEC int n = p->zKey ? strlen(p->zKey) : 0; - db = p->db = sqlite_open_encrypted(p->zDbFilename, p->zKey, n, 0, &zErrMsg); + db = p->db = sqlite3_open_encrypted(p->zDbFilename, p->zKey, n, 0, &zErrMsg); #else - db = p->db = sqlite_open(p->zDbFilename, 0, &zErrMsg); + db = p->db = sqlite3_open(p->zDbFilename, 0, &zErrMsg); #endif if( p->db==0 ){ if( zErrMsg ){ @@ -576,10 +576,10 @@ static int do_meta_command(char *zLine, struct callback_data *p){ data.colWidth[0] = 3; data.colWidth[1] = 15; data.colWidth[2] = 58; - sqlite_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg); + sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg); if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); } }else @@ -588,7 +588,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ open_db(p); fprintf(p->out, "BEGIN TRANSACTION;\n"); if( nArg==1 ){ - sqlite_exec(p->db, + sqlite3_exec(p->db, "SELECT name, type, sql FROM sqlite_master " "WHERE type!='meta' AND sql NOT NULL " "ORDER BY substr(type,2,1), name", @@ -597,7 +597,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ }else{ int i; for(i=1; i<nArg && zErrMsg==0; i++){ - sqlite_exec_printf(p->db, + sqlite3_exec_printf(p->db, "SELECT name, type, sql FROM sqlite_master " "WHERE tbl_name LIKE '%q' AND type!='meta' AND sql NOT NULL " "ORDER BY substr(type,2,1), name", @@ -607,7 +607,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ } if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); }else{ fprintf(p->out, "COMMIT;\n"); } @@ -702,7 +702,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ memcpy(&data, p, sizeof(data)); data.showHeader = 0; data.mode = MODE_List; - sqlite_exec_printf(p->db, + sqlite3_exec_printf(p->db, "SELECT name FROM sqlite_master " "WHERE type='index' AND tbl_name LIKE '%q' " "UNION ALL " @@ -713,7 +713,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ ); if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); } }else @@ -797,8 +797,8 @@ static int do_meta_command(char *zLine, struct callback_data *p){ }else if( strcmp(azArg[2], azArg[3]) ){ fprintf(stderr,"2nd copy of new key does not match the 1st\n"); }else{ - sqlite_freemem(p->zKey); - p->zKey = sqlite_mprintf("%s", azArg[2]); + sqlite3_freemem(p->zKey); + p->zKey = sqlite3_mprintf("%s", azArg[2]); sqlite_rekey(p->db, p->zKey, strlen(p->zKey)); } }else @@ -840,7 +840,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ new_colv[1] = 0; callback(&data, 1, new_argv, new_colv); }else{ - sqlite_exec_printf(p->db, + sqlite3_exec_printf(p->db, "SELECT sql FROM " " (SELECT * FROM sqlite_master UNION ALL" " SELECT * FROM sqlite_temp_master) " @@ -849,7 +849,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ callback, &data, &zErrMsg, azArg[1]); } }else{ - sqlite_exec(p->db, + sqlite3_exec(p->db, "SELECT sql FROM " " (SELECT * FROM sqlite_master UNION ALL" " SELECT * FROM sqlite_temp_master) " @@ -860,7 +860,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ } if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); } }else @@ -891,7 +891,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ char *zErrMsg; open_db(p); if( nArg==1 ){ - rc = sqlite_get_table(p->db, + rc = sqlite3_get_table(p->db, "SELECT name FROM sqlite_master " "WHERE type IN ('table','view') " "UNION ALL " @@ -901,7 +901,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ &azResult, &nRow, 0, &zErrMsg ); }else{ - rc = sqlite_get_table_printf(p->db, + rc = sqlite3_get_table_printf(p->db, "SELECT name FROM sqlite_master " "WHERE type IN ('table','view') AND name LIKE '%%%q%%' " "UNION ALL " @@ -913,7 +913,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ } if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); } if( rc==SQLITE_OK ){ int len, maxlen = 0; @@ -935,12 +935,12 @@ static int do_meta_command(char *zLine, struct callback_data *p){ printf("\n"); } } - sqlite_free_table(azResult); + sqlite3_free_table(azResult); }else if( c=='t' && n>1 && strncmp(azArg[0], "timeout", n)==0 && nArg>=2 ){ open_db(p); - sqlite_busy_timeout(p->db, atoi(azArg[1])); + sqlite3_busy_timeout(p->db, atoi(azArg[1])); }else if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ @@ -1055,18 +1055,18 @@ static void process_input(struct callback_data *p, FILE *in){ nSql += len; } free(zLine); - if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite_complete(zSql) ){ + if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite3_complete(zSql) ){ p->cnt = 0; open_db(p); - rc = sqlite_exec(p->db, zSql, callback, p, &zErrMsg); + rc = sqlite3_exec(p->db, zSql, callback, p, &zErrMsg); if( rc || zErrMsg ){ if( in!=0 && !p->echoOn ) printf("%s\n",zSql); if( zErrMsg!=0 ){ printf("SQL error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); zErrMsg = 0; }else{ - printf("SQL error: %s\n", sqlite_error_string(rc)); + printf("SQL error: %s\n", sqlite3_error_string(rc)); } } free(zSql); @@ -1239,7 +1239,7 @@ int main(int argc, char **argv){ zInitFile = argv[i]; }else if( strcmp(argv[i],"-key")==0 ){ i++; - data.zKey = sqlite_mprintf("%s",argv[i]); + data.zKey = sqlite3_mprintf("%s",argv[i]); } } if( i<argc ){ @@ -1297,7 +1297,7 @@ int main(int argc, char **argv){ }else if( strcmp(z,"-echo")==0 ){ data.echoOn = 1; }else if( strcmp(z,"-version")==0 ){ - printf("%s\n", sqlite_version); + printf("%s\n", sqlite3_version); return 1; }else if( strcmp(z,"-help")==0 ){ usage(1); @@ -1317,7 +1317,7 @@ int main(int argc, char **argv){ }else{ int rc; open_db(&data); - rc = sqlite_exec(data.db, zFirstCmd, callback, &data, &zErrMsg); + rc = sqlite3_exec(data.db, zFirstCmd, callback, &data, &zErrMsg); if( rc!=0 && zErrMsg!=0 ){ fprintf(stderr,"SQL error: %s\n", zErrMsg); exit(1); @@ -1332,7 +1332,7 @@ int main(int argc, char **argv){ printf( "SQLite version %s\n" "Enter \".help\" for instructions\n", - sqlite_version + sqlite3_version ); zHome = find_home_dir(); if( zHome && (zHistory = malloc(strlen(zHome)+20))!=0 ){ @@ -1349,7 +1349,7 @@ int main(int argc, char **argv){ } } set_table_name(&data, 0); - if( db ) sqlite_close(db); + if( db ) sqlite3_close(db); return 0; } diff --git a/src/sqlite.h.in b/src/sqlite.h.in index 3b210ebe0..272735d83 100644 --- a/src/sqlite.h.in +++ b/src/sqlite.h.in @@ -12,7 +12,7 @@ ** This header file defines the interface that the SQLite library ** presents to client programs. ** -** @(#) $Id: sqlite.h.in,v 1.61 2004/05/08 08:23:33 danielk1977 Exp $ +** @(#) $Id: sqlite.h.in,v 1.62 2004/05/10 10:34:52 danielk1977 Exp $ */ #ifndef _SQLITE_H_ #define _SQLITE_H_ @@ -35,7 +35,7 @@ extern "C" { ** can check to make sure that the lib*.a file and the *.h file are from ** the same version. */ -extern const char sqlite_version[]; +extern const char sqlite3_version[]; /* ** The SQLITE_UTF8 macro is defined if the library expects to see @@ -50,7 +50,7 @@ extern const char sqlite_version[]; ** see. The character encoding makes a difference for the LIKE and GLOB ** operators and for the LENGTH() and SUBSTR() functions. */ -extern const char sqlite_encoding[]; +extern const char sqlite3_encoding[]; /* ** Each open sqlite database is represented by an instance of the @@ -75,15 +75,15 @@ typedef struct sqlite sqlite; ** ability to open a database readonly. The mode parameters is ** provided in anticipation of that enhancement. */ -sqlite *sqlite_open(const char *filename, int mode, char **errmsg); +sqlite *sqlite3_open(const 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. +** returned from sqlite3_open() and the corresponding database will by closed. */ -void sqlite_close(sqlite *); +void sqlite3_close(sqlite *); /* ** The type for a callback function. @@ -98,7 +98,7 @@ typedef int (*sqlite_callback)(void*,int,char**, char**); ** 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. +** are skipped and the sqlite3_exec() function returns the SQLITE_ABORT. ** ** The 4th parameter is an arbitrary pointer that is passed ** to the callback function as its first parameter. @@ -118,7 +118,7 @@ typedef int (*sqlite_callback)(void*,int,char**, char**); ** 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, +** message. Use sqlite3_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 @@ -127,10 +127,10 @@ typedef int (*sqlite_callback)(void*,int,char**, char**); ** ** 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.) +** behavior can be modified somewhat using the sqlite3_busy_handler() +** and sqlite3_busy_timeout() functions below.) */ -int sqlite_exec( +int sqlite3_exec( sqlite*, /* An open database */ const char *sql, /* SQL to be executed */ sqlite_callback, /* Callback function */ @@ -139,7 +139,7 @@ int sqlite_exec( ); /* -** Return values for sqlite_exec() and sqlite_step() +** Return values for sqlite3_exec() and sqlite3_step() */ #define SQLITE_OK 0 /* Successful result */ #define SQLITE_ERROR 1 /* SQL error or missing database */ @@ -150,7 +150,7 @@ int sqlite_exec( #define SQLITE_LOCKED 6 /* A table in the database is locked */ #define SQLITE_NOMEM 7 /* A malloc() failed */ #define SQLITE_READONLY 8 /* Attempt to write a readonly database */ -#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite_interrupt() */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt() */ #define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ #define SQLITE_CORRUPT 11 /* The database disk image is malformed */ #define SQLITE_NOTFOUND 12 /* (Internal Only) Table or record not found */ @@ -166,10 +166,10 @@ int sqlite_exec( #define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ #define SQLITE_AUTH 23 /* Authorization denied */ #define SQLITE_FORMAT 24 /* Auxiliary database format error */ -#define SQLITE_RANGE 25 /* 2nd parameter to sqlite_bind out of range */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ #define SQLITE_NOTADB 26 /* File opened that is not a database file */ -#define SQLITE_ROW 100 /* sqlite_step() has another row ready */ -#define SQLITE_DONE 101 /* sqlite_step() has finished executing */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ /* ** Each entry in an SQLite table has a unique integer key. (The key is @@ -180,17 +180,17 @@ int sqlite_exec( ** ** This function is similar to the mysql_insert_id() function from MySQL. */ -int sqlite_last_insert_rowid(sqlite*); +int sqlite3_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(). +** (or inserted or deleted) by the most recent called sqlite3_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 +** If a callback invokes sqlite3_exec() recursively, then the changes ** in the inner, recursive call are counted together with the changes ** in the outer call. ** @@ -202,11 +202,11 @@ int sqlite_last_insert_rowid(sqlite*); ** table. To get an accurate count of the number of rows deleted, use ** "DELETE FROM table WHERE 1" instead. */ -int sqlite_changes(sqlite*); +int sqlite3_changes(sqlite*); /* ** This function returns the number of database rows that were changed -** by the last INSERT, UPDATE, or DELETE statment executed by sqlite_exec(), +** by the last INSERT, UPDATE, or DELETE statment executed by sqlite3_exec(), ** or by the last VM to run to completion. The change count is not updated ** by SQL statements other than INSERT, UPDATE or DELETE. ** @@ -214,7 +214,7 @@ int sqlite_changes(sqlite*); ** ABORT. Changes associated with trigger programs that execute as a ** result of the INSERT, UPDATE, or DELETE statement are not counted. ** -** If a callback invokes sqlite_exec() recursively, then the changes +** If a callback invokes sqlite3_exec() recursively, then the changes ** in the inner, recursive call are counted together with the changes ** in the outer call. ** @@ -228,14 +228,14 @@ int sqlite_changes(sqlite*); ** ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** */ -int sqlite_last_statement_changes(sqlite*); +int sqlite3_last_statement_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. */ -const char *sqlite_error_string(int); -#define sqliteErrStr sqlite_error_string /* Legacy. Do not use in new code. */ +const char *sqlite3_error_string(int); +#define sqliteErrStr sqlite3_error_string /* Legacy. Do not use in new code. */ /* This function causes any pending database operation to abort and ** return at its earliest opportunity. This routine is typically @@ -243,7 +243,7 @@ const char *sqlite_error_string(int); ** or Ctrl-C where the user wants a long query operation to halt ** immediately. */ -void sqlite_interrupt(sqlite*); +void sqlite3_interrupt(sqlite*); /* This function returns true if the given input string comprises @@ -253,19 +253,19 @@ void sqlite_interrupt(sqlite*); ** and comments is a semicolon, then return true. otherwise return ** false. */ -int sqlite_complete(const char *sql); +int sqlite3_complete(const 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 +** is NULL, then sqlite3_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 +** sqlite3_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() +** busy callback returns 0, then sqlite3_exec() immediately returns +** SQLITE_BUSY. If the callback returns non-zero, then sqlite3_exec() ** tries to open the table again and the cycle repeats. ** ** The default busy callback is NULL. @@ -277,22 +277,22 @@ int sqlite_complete(const char *sql); ** data structures out from under the executing query and will ** probably result in a coredump. */ -void sqlite_busy_handler(sqlite*, int(*)(void*,const char*,int), void*); +void sqlite3_busy_handler(sqlite*, int(*)(void*,const 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. +** causes sqlite3_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); +void sqlite3_busy_timeout(sqlite*, int ms); /* -** This next routine is really just a wrapper around sqlite_exec(). +** This next routine is really just a wrapper around sqlite3_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 @@ -324,15 +324,15 @@ void sqlite_busy_timeout(sqlite*, int ms); ** 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 +** pass the result data pointer to sqlite3_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 +** malloc() directly. Only sqlite3_free_table() is able to release ** the memory properly and safely. ** -** The return value of this routine is the same as from sqlite_exec(). +** The return value of this routine is the same as from sqlite3_exec(). */ -int sqlite_get_table( +int sqlite3_get_table( sqlite*, /* An open database */ const char *sql, /* SQL to be executed */ char ***resultp, /* Result written to a char *[] that this points to */ @@ -342,13 +342,13 @@ int sqlite_get_table( ); /* -** Call this routine to free the memory that sqlite_get_table() allocated. +** Call this routine to free the memory that sqlite3_get_table() allocated. */ -void sqlite_free_table(char **result); +void sqlite3_free_table(char **result); /* -** The following routines are wrappers around sqlite_exec() and -** sqlite_get_table(). The only difference between the routines that +** The following routines are wrappers around sqlite3_exec() and +** sqlite3_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 @@ -367,7 +367,7 @@ void sqlite_free_table(char **result); ** ** We can use this text in an SQL statement as follows: ** -** sqlite_exec_printf(db, "INSERT INTO table VALUES('%q')", +** sqlite3_exec_printf(db, "INSERT INTO table VALUES('%q')", ** callback1, 0, 0, zText); ** ** Because the %q format string is used, the '\'' character in zText @@ -384,7 +384,7 @@ void sqlite_free_table(char **result); ** should always use %q instead of %s when inserting text into a string ** literal. */ -int sqlite_exec_printf( +int sqlite3_exec_printf( sqlite*, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ sqlite_callback, /* Callback function */ @@ -392,7 +392,7 @@ int sqlite_exec_printf( char **errmsg, /* Error msg written here */ ... /* Arguments to the format string. */ ); -int sqlite_exec_vprintf( +int sqlite3_exec_vprintf( sqlite*, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ sqlite_callback, /* Callback function */ @@ -400,7 +400,7 @@ int sqlite_exec_vprintf( char **errmsg, /* Error msg written here */ va_list ap /* Arguments to the format string. */ ); -int sqlite_get_table_printf( +int sqlite3_get_table_printf( sqlite*, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ char ***resultp, /* Result written to a char *[] that this points to */ @@ -409,7 +409,7 @@ int sqlite_get_table_printf( char **errmsg, /* Error msg written here */ ... /* Arguments to the format string */ ); -int sqlite_get_table_vprintf( +int sqlite3_get_table_vprintf( sqlite*, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ char ***resultp, /* Result written to a char *[] that this points to */ @@ -418,23 +418,23 @@ int sqlite_get_table_vprintf( char **errmsg, /* Error msg written here */ va_list ap /* Arguments to the format string */ ); -char *sqlite_mprintf(const char*,...); -char *sqlite_vmprintf(const char*, va_list); +char *sqlite3_mprintf(const char*,...); +char *sqlite3_vmprintf(const 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 +** is returned in the in the errmsg parameter of sqlite3_open() when ** SQLite is a DLL. For some reason, it does not work to call free() ** directly. */ -void sqlite_freemem(void *p); +void sqlite3_freemem(void *p); /* -** Windows systems need functions to call to return the sqlite_version -** and sqlite_encoding strings. +** Windows systems need functions to call to return the sqlite3_version +** and sqlite3_encoding strings. */ -const char *sqlite_libversion(void); -const char *sqlite_libencoding(void); +const char *sqlite3_libversion(void); +const char *sqlite3_libencoding(void); /* ** A pointer to the following structure is used to communicate with @@ -446,20 +446,20 @@ typedef struct sqlite_func sqlite_func; ** Use the following routines to create new user-defined functions. See ** the documentation for details. */ -int sqlite_create_function( +int sqlite3_create_function( sqlite*, /* Database where the new function is registered */ const char *zName, /* Name of the new function */ int nArg, /* Number of arguments. -1 means any number */ void (*xFunc)(sqlite_func*,int,const char**), /* C code to implement */ - void *pUserData /* Available via the sqlite_user_data() call */ + void *pUserData /* Available via the sqlite3_user_data() call */ ); -int sqlite_create_aggregate( +int sqlite3_create_aggregate( sqlite*, /* Database where the new function is registered */ const char *zName, /* Name of the function */ int nArg, /* Number of arguments */ void (*xStep)(sqlite_func*,int,const char**), /* Called for each row */ void (*xFinalize)(sqlite_func*), /* Called once to get final result */ - void *pUserData /* Available via the sqlite_user_data() call */ + void *pUserData /* Available via the sqlite3_user_data() call */ ); /* @@ -473,7 +473,7 @@ int sqlite_create_aggregate( ** the result is always text. If datatype==SQLITE_ARGS then the result ** is numeric if any argument is numeric and is text otherwise. */ -int sqlite_function_type( +int sqlite3_function_type( sqlite *db, /* The database there the function is registered */ const char *zName, /* Name of the function */ int datatype /* The datatype for this function */ @@ -487,30 +487,30 @@ int sqlite_function_type( ** 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() +** A NULL can be passed as the second parameter to sqlite3_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 +** The sqlite3_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*,const 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*,const char*,int); +char *sqlite3_set_result_string(sqlite_func*,const char*,int); +void sqlite3_set_result_int(sqlite_func*,int); +void sqlite3_set_result_double(sqlite_func*,double); +void sqlite3_set_result_error(sqlite_func*,const char*,int); /* -** The pUserData parameter to the sqlite_create_function() and -** sqlite_create_aggregate() routines used to register user functions +** The pUserData parameter to the sqlite3_create_function() and +** sqlite3_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*); +void *sqlite3_user_data(sqlite_func*); /* ** Aggregate functions use the following routine to allocate @@ -522,14 +522,14 @@ void *sqlite_user_data(sqlite_func*); ** ** The buffer allocated is freed automatically be SQLite. */ -void *sqlite_aggregate_context(sqlite_func*, int nBytes); +void *sqlite3_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*); +int sqlite3_aggregate_count(sqlite_func*); /* ** This routine registers a callback with the SQLite library. The @@ -539,7 +539,7 @@ int sqlite_aggregate_count(sqlite_func*); ** 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( +int sqlite3_set_authorizer( sqlite*, int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), void *pUserData @@ -595,11 +595,11 @@ int sqlite_set_authorizer( #define 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 +** Register a function that is called at every invocation of sqlite3_exec() +** or sqlite3_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*,const char*), void*); +void *sqlite3_trace(sqlite*, void(*xTrace)(void*,const char*), void*); /*** The Callback-Free API ** @@ -614,7 +614,7 @@ typedef struct sqlite_vm 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 +** to an sqlite object obtained from sqlite3_open(). The 2nd parameter ** "zSql" is the text of the SQL to be compiled. The remaining parameters ** are all outputs. ** @@ -630,13 +630,13 @@ typedef struct sqlite_vm sqlite_vm; ** 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 +** of this message when it has finished with it. Use sqlite3_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( +int sqlite3_compile( sqlite *db, /* The open database */ const char *zSql, /* SQL statement to be compiled */ const char **pzTail, /* OUT: uncompiled tail of zSql */ @@ -651,7 +651,7 @@ int sqlite_compile( ** 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 +** an no errors have occurred. sqlite3_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 @@ -659,16 +659,16 @@ int sqlite_compile( ** (*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 +** error. sqlite3_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 +** to NULL. Use sqlite3_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. +** can try again to open the database by calling sqlite3_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 +** using the sqlite3_busy_handler() or sqlite3_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. @@ -676,16 +676,16 @@ int sqlite_compile( ** 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. +** Invoke sqlite3_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 +** SQLITE_MISUSE is returned if sqlite3_step() is called incorrectly. +** For example, if you call sqlite3_step() after the virtual machine +** has halted (after a prior call to sqlite3_step() has returned SQLITE_DONE) +** or if you call sqlite3_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( +int sqlite3_step( sqlite_vm *pVm, /* The virtual machine to execute */ int *pN, /* OUT: Number of columns in result */ const char ***pazValue, /* OUT: Column data */ @@ -699,39 +699,39 @@ int sqlite_step( ** 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 +** should use sqlite3_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 +** an interrupt. (See sqlite3_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); +int sqlite3_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. +** sqlite3_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. +** If sqlite3_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); +int sqlite3_reset(sqlite_vm*, char **pzErrMsg); /* -** If the SQL that was handed to sqlite_compile contains variables that +** If the SQL that was handed to sqlite3_compile contains variables that ** are represeted in the SQL text by a question mark ('?'). This routine ** is used to assign values to those variables. ** -** The first parameter is a virtual machine obtained from sqlite_compile(). +** The first parameter is a virtual machine obtained from sqlite3_compile(). ** The 2nd "idx" parameter determines which variable in the SQL statement ** to bind the value to. The left most '?' is 1. The 3rd parameter is ** the value to assign to that variable. The 4th parameter is the number @@ -748,17 +748,17 @@ int sqlite_reset(sqlite_vm*, char **pzErrMsg); ** If the 4th "len" parameter is -1, then strlen() is used to find the ** length. ** -** This routine can only be called immediately after sqlite_compile() -** or sqlite_reset() and before any calls to sqlite_step(). +** This routine can only be called immediately after sqlite3_compile() +** or sqlite3_reset() and before any calls to sqlite3_step(). ** ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** */ -int sqlite_bind(sqlite_vm*, int idx, const char *value, int len, int copy); +int sqlite3_bind(sqlite_vm*, int idx, const char *value, int len, int copy); /* ** This routine configures a callback function - the progress callback - that -** is invoked periodically during long running calls to sqlite_exec(), -** sqlite_step() and sqlite_get_table(). An example use for this API is to keep +** is invoked periodically during long running calls to sqlite3_exec(), +** sqlite3_step() and sqlite3_get_table(). An example use for this API is to keep ** a GUI updated during a large query. ** ** The progress callback is invoked once for every N virtual machine opcodes, @@ -767,7 +767,7 @@ int sqlite_bind(sqlite_vm*, int idx, const char *value, int len, int copy); ** argument to this function is a void pointer passed to the progress callback ** function each time it is invoked. ** -** If a call to sqlite_exec(), sqlite_step() or sqlite_get_table() results +** If a call to sqlite3_exec(), sqlite3_step() or sqlite3_get_table() results ** in less than N opcodes being executed, then the progress callback is not ** invoked. ** @@ -778,11 +778,11 @@ int sqlite_bind(sqlite_vm*, int idx, const char *value, int len, int copy); ** If the progress callback returns a result other than 0, then the current ** query is immediately terminated and any database changes rolled back. If the ** query was part of a larger transaction, then the transaction is not rolled -** back and remains active. The sqlite_exec() call returns SQLITE_ABORT. +** back and remains active. The sqlite3_exec() call returns SQLITE_ABORT. ** ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** */ -void sqlite_progress_handler(sqlite*, int, int(*)(void*), void*); +void sqlite3_progress_handler(sqlite*, int, int(*)(void*), void*); /* ** Register a callback function to be invoked whenever a new transaction @@ -797,16 +797,16 @@ void sqlite_progress_handler(sqlite*, int, int(*)(void*), void*); ** ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** */ -void *sqlite_commit_hook(sqlite*, int(*)(void*), void*); +void *sqlite3_commit_hook(sqlite*, int(*)(void*), void*); /* ** Open an encrypted SQLite database. If pKey==0 or nKey==0, this routine -** is the same as sqlite_open(). +** is the same as sqlite3_open(). ** ** The code to implement this API is not available in the public release ** of SQLite. */ -sqlite *sqlite_open_encrypted( +sqlite *sqlite3_open_encrypted( const char *zFilename, /* Name of the encrypted database */ const void *pKey, /* Pointer to the key */ int nKey, /* Number of bytes in the key */ diff --git a/src/sqliteInt.h b/src/sqliteInt.h index c2a5be917..a04fb2c98 100644 --- a/src/sqliteInt.h +++ b/src/sqliteInt.h @@ -11,7 +11,7 @@ ************************************************************************* ** Internal interface definitions for SQLite. ** -** @(#) $Id: sqliteInt.h,v 1.227 2004/05/10 10:05:54 danielk1977 Exp $ +** @(#) $Id: sqliteInt.h,v 1.228 2004/05/10 10:34:52 danielk1977 Exp $ */ #include "config.h" #include "sqlite.h" @@ -197,16 +197,16 @@ typedef unsigned INTPTR_TYPE uptr; /* Big enough to hold a pointer */ ** This variable gets set if malloc() ever fails. After it gets set, ** the SQLite library shuts down permanently. */ -extern int sqlite_malloc_failed; +extern int sqlite3_malloc_failed; /* ** The following global variables are used for testing and debugging ** only. They only work if MEMORY_DEBUG is defined. */ #ifdef MEMORY_DEBUG -extern int sqlite_nMalloc; /* Number of sqliteMalloc() calls */ -extern int sqlite_nFree; /* Number of sqliteFree() calls */ -extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ +extern int sqlite3_nMalloc; /* Number of sqliteMalloc() calls */ +extern int sqlite3_nFree; /* Number of sqliteFree() calls */ +extern int sqlite3_iMallocFail; /* Fail sqliteMalloc() after this many calls */ #endif /* @@ -339,7 +339,7 @@ struct Db { ** longer (since after version 2.8.12) reset to -1. ** ** The sqlite.nChange does not count changes within triggers and keeps no -** context. It is reset at start of sqlite_exec. +** context. It is reset at start of sqlite3_exec. ** The sqlite.lsChange represents the number of changes made by the last ** insert, update, or delete statement. It remains constant throughout the ** length of a statement and is then updated by OP_SetCounts. It keeps a @@ -1276,7 +1276,7 @@ int sqlite3FixExpr(DbFixer*, Expr*); int sqlite3FixExprList(DbFixer*, ExprList*); int sqlite3FixTriggerStep(DbFixer*, TriggerStep*); double sqlite3AtoF(const char *z, const char **); -char *sqlite_snprintf(int,char*,const char*,...); +char *sqlite3_snprintf(int,char*,const char*,...); int sqlite3FitsIn32Bits(const char *); unsigned char *sqlite3utf16to8(const void *pData, int N); diff --git a/src/table.c b/src/table.c index 39692c220..f47ba60a2 100644 --- a/src/table.c +++ b/src/table.c @@ -9,9 +9,9 @@ ** May you share freely, never taking more than you give. ** ************************************************************************* -** This file contains the sqlite_get_table() and sqlite_free_table() +** This file contains the sqlite3_get_table() and sqlite3_free_table() ** interface routines. These are just wrappers around the main -** interface routine of sqlite_exec(). +** interface routine of sqlite3_exec(). ** ** These routines are in a separate files so that they will not be linked ** if they are not used. @@ -21,7 +21,7 @@ #include "sqliteInt.h" /* -** This structure is used to pass data from sqlite_get_table() through +** This structure is used to pass data from sqlite3_get_table() through ** to the callback function is uses to build the result. */ typedef struct TabResult { @@ -40,7 +40,7 @@ typedef struct TabResult { ** is to fill in the TabResult structure appropriately, allocating new ** memory as necessary. */ -static int sqlite_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ +static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ TabResult *p = (TabResult*)pArg; int need; int i; @@ -85,7 +85,7 @@ static int sqlite_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ } }else if( p->nColumn!=nCol ){ sqlite3SetString(&p->zErrMsg, - "sqlite_get_table() called with two or more incompatible queries", + "sqlite3_get_table() called with two or more incompatible queries", (char*)0); p->rc = SQLITE_ERROR; return 1; @@ -119,10 +119,10 @@ static int sqlite_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ ** ** The result that is written to ***pazResult is held in memory obtained ** from malloc(). But the caller cannot free this memory directly. -** Instead, the entire table should be passed to sqlite_free_table() when +** Instead, the entire table should be passed to sqlite3_free_table() when ** the calling procedure is finished using it. */ -int sqlite_get_table( +int sqlite3_get_table( sqlite *db, /* The database on which the SQL executes */ const char *zSql, /* The SQL to be executed */ char ***pazResult, /* Write the result table here */ @@ -148,12 +148,12 @@ int sqlite_get_table( return SQLITE_NOMEM; } res.azResult[0] = 0; - rc = sqlite_exec(db, zSql, sqlite_get_table_cb, &res, pzErrMsg); + rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg); if( res.azResult ){ res.azResult[0] = (char*)res.nData; } if( rc==SQLITE_ABORT ){ - sqlite_free_table(&res.azResult[1]); + sqlite3_free_table(&res.azResult[1]); if( res.zErrMsg ){ if( pzErrMsg ){ free(*pzErrMsg); @@ -167,14 +167,14 @@ int sqlite_get_table( } sqliteFree(res.zErrMsg); if( rc!=SQLITE_OK ){ - sqlite_free_table(&res.azResult[1]); + sqlite3_free_table(&res.azResult[1]); return rc; } if( res.nAlloc>res.nData ){ char **azNew; azNew = realloc( res.azResult, sizeof(char*)*(res.nData+1) ); if( azNew==0 ){ - sqlite_free_table(&res.azResult[1]); + sqlite3_free_table(&res.azResult[1]); return SQLITE_NOMEM; } res.nAlloc = res.nData+1; @@ -187,10 +187,10 @@ int sqlite_get_table( } /* -** This routine frees the space the sqlite_get_table() malloced. +** This routine frees the space the sqlite3_get_table() malloced. */ -void sqlite_free_table( - char **azResult /* Result returned from from sqlite_get_table() */ +void sqlite3_free_table( + char **azResult /* Result returned from from sqlite3_get_table() */ ){ if( azResult ){ int i, n; diff --git a/src/tclsqlite.c b/src/tclsqlite.c index 474a72b84..2c3b9211d 100644 --- a/src/tclsqlite.c +++ b/src/tclsqlite.c @@ -11,7 +11,7 @@ ************************************************************************* ** A TCL Interface to SQLite ** -** $Id: tclsqlite.c,v 1.63 2004/05/08 08:23:37 danielk1977 Exp $ +** $Id: tclsqlite.c,v 1.64 2004/05/10 10:34:53 danielk1977 Exp $ */ #ifndef NO_TCL /* Omit this whole file if TCL is unavailable */ @@ -56,7 +56,7 @@ struct SqliteDb { char *zProgress; /* The progress callback routine */ char *zAuth; /* The authorization callback routine */ SqlFunc *pFunc; /* List of SQL functions */ - int rc; /* Return code of most recent sqlite_exec() */ + int rc; /* Return code of most recent sqlite3_exec() */ }; /* @@ -185,10 +185,10 @@ static int DbEvalCallback( Tcl_SetVar2(cbData->interp, cbData->zArray, "*", azN[i], TCL_LIST_ELEMENT|TCL_APPEND_VALUE); if( azN[nCol] ){ - char *z = sqlite_mprintf("typeof:%s", azN[i]); + char *z = sqlite3_mprintf("typeof:%s", azN[i]); Tcl_SetVar2(cbData->interp, cbData->zArray, z, azN[i+nCol], TCL_LIST_ELEMENT|TCL_APPEND_VALUE); - sqlite_freemem(z); + sqlite3_freemem(z); } } cbData->once = 0; @@ -284,7 +284,7 @@ static int DbEvalCallback3( */ static void DbDeleteCmd(void *db){ SqliteDb *pDb = (SqliteDb*)db; - sqlite_close(pDb->db); + sqlite3_close(pDb->db); while( pDb->pFunc ){ SqlFunc *pFunc = pDb->pFunc; pDb->pFunc = pFunc->pNext; @@ -380,7 +380,7 @@ static int DbCommitHandler(void *cd){ ** using TCL script. */ static void tclSqlFunc(sqlite_func *context, int argc, const char **argv){ - SqlFunc *p = sqlite_user_data(context); + SqlFunc *p = sqlite3_user_data(context); Tcl_DString cmd; int i; int rc; @@ -392,9 +392,9 @@ static void tclSqlFunc(sqlite_func *context, int argc, const char **argv){ } rc = Tcl_Eval(p->interp, Tcl_DStringValue(&cmd)); if( rc ){ - sqlite_set_result_error(context, Tcl_GetStringResult(p->interp), -1); + sqlite3_set_result_error(context, Tcl_GetStringResult(p->interp), -1); }else{ - sqlite_set_result_string(context, Tcl_GetStringResult(p->interp), -1); + sqlite3_set_result_string(context, Tcl_GetStringResult(p->interp), -1); } } #ifndef SQLITE_OMIT_AUTHORIZATION @@ -556,9 +556,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ #ifndef SQLITE_OMIT_AUTHORIZATION if( pDb->zAuth ){ pDb->interp = interp; - sqlite_set_authorizer(pDb->db, auth_callback, pDb); + sqlite3_set_authorizer(pDb->db, auth_callback, pDb); }else{ - sqlite_set_authorizer(pDb->db, 0, 0); + sqlite3_set_authorizer(pDb->db, 0, 0); } #endif } @@ -593,9 +593,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ } if( pDb->zBusy ){ pDb->interp = interp; - sqlite_busy_handler(pDb->db, DbBusyHandler, pDb); + sqlite3_busy_handler(pDb->db, DbBusyHandler, pDb); }else{ - sqlite_busy_handler(pDb->db, 0, 0); + sqlite3_busy_handler(pDb->db, 0, 0); } } break; @@ -631,9 +631,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ #ifndef SQLITE_OMIT_PROGRESS_CALLBACK if( pDb->zProgress ){ pDb->interp = interp; - sqlite_progress_handler(pDb->db, N, DbProgressHandler, pDb); + sqlite3_progress_handler(pDb->db, N, DbProgressHandler, pDb); }else{ - sqlite_progress_handler(pDb->db, 0, 0, 0); + sqlite3_progress_handler(pDb->db, 0, 0, 0); } #endif }else{ @@ -656,7 +656,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ Tcl_WrongNumArgs(interp, 2, objv, ""); return TCL_ERROR; } - nChange = sqlite_changes(pDb->db); + nChange = sqlite3_changes(pDb->db); pResult = Tcl_GetObjResult(interp); Tcl_SetIntObj(pResult, nChange); break; @@ -676,7 +676,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ Tcl_WrongNumArgs(interp, 2, objv, ""); return TCL_ERROR; } - lsChange = sqlite_last_statement_changes(pDb->db); + lsChange = sqlite3_last_statement_changes(pDb->db); pResult = Tcl_GetObjResult(interp); Tcl_SetIntObj(pResult, lsChange); break; @@ -720,9 +720,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ } if( pDb->zCommit ){ pDb->interp = interp; - sqlite_commit_hook(pDb->db, DbCommitHandler, pDb); + sqlite3_commit_hook(pDb->db, DbCommitHandler, pDb); }else{ - sqlite_commit_hook(pDb->db, 0, 0); + sqlite3_commit_hook(pDb->db, 0, 0); } } break; @@ -741,7 +741,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ Tcl_WrongNumArgs(interp, 2, objv, "SQL"); return TCL_ERROR; } - isComplete = sqlite_complete( Tcl_GetStringFromObj(objv[2], 0) ); + isComplete = sqlite3_complete( Tcl_GetStringFromObj(objv[2], 0) ); pResult = Tcl_GetObjResult(interp); Tcl_SetBooleanObj(pResult, isComplete); break; @@ -751,7 +751,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ ** $db errorcode ** ** Return the numeric error code that was returned by the most recent - ** call to sqlite_exec(). + ** call to sqlite3_exec(). */ case DB_ERRORCODE: { Tcl_SetObjResult(interp, Tcl_NewIntObj(pDb->rc)); @@ -799,14 +799,14 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ zErrMsg = 0; Tcl_IncrRefCount(objv[3]); Tcl_IncrRefCount(objv[4]); - rc = sqlite_exec(pDb->db, zSql, DbEvalCallback, &cbData, &zErrMsg); + rc = sqlite3_exec(pDb->db, zSql, DbEvalCallback, &cbData, &zErrMsg); Tcl_DecrRefCount(objv[4]); Tcl_DecrRefCount(objv[3]); if( cbData.tcl_rc==TCL_BREAK ){ cbData.tcl_rc = TCL_OK; } }else{ Tcl_Obj *pList = Tcl_NewObj(); cbData.tcl_rc = TCL_OK; - rc = sqlite_exec(pDb->db, zSql, DbEvalCallback2, pList, &zErrMsg); + rc = sqlite3_exec(pDb->db, zSql, DbEvalCallback2, pList, &zErrMsg); Tcl_SetObjResult(interp, pList); } pDb->rc = rc; @@ -818,7 +818,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ free(zErrMsg); rc = TCL_ERROR; }else if( rc!=SQLITE_OK ){ - Tcl_AppendResult(interp, sqlite_error_string(rc), 0); + Tcl_AppendResult(interp, sqlite3_error_string(rc), 0); rc = TCL_ERROR; }else{ } @@ -859,8 +859,8 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ pFunc->pNext = pDb->pFunc; pFunc->zScript = (char*)&pFunc[1]; strcpy(pFunc->zScript, zScript); - sqlite_create_function(pDb->db, zName, -1, tclSqlFunc, pFunc); - sqlite_function_type(pDb->db, zName, SQLITE_NUMERIC); + sqlite3_create_function(pDb->db, zName, -1, tclSqlFunc, pFunc); + sqlite3_function_type(pDb->db, zName, SQLITE_NUMERIC); break; } @@ -876,7 +876,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ Tcl_WrongNumArgs(interp, 2, objv, ""); return TCL_ERROR; } - rowid = sqlite_last_insert_rowid(pDb->db); + rowid = sqlite3_last_insert_rowid(pDb->db); pResult = Tcl_GetObjResult(interp); Tcl_SetIntObj(pResult, rowid); break; @@ -895,7 +895,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ return TCL_ERROR; } zSql = Tcl_GetStringFromObj(objv[2], 0); - rc = sqlite_exec(pDb->db, zSql, DbEvalCallback3, interp, &zErrMsg); + rc = sqlite3_exec(pDb->db, zSql, DbEvalCallback3, interp, &zErrMsg); if( rc==SQLITE_ABORT ){ rc = SQLITE_OK; }else if( zErrMsg ){ @@ -903,7 +903,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ free(zErrMsg); rc = TCL_ERROR; }else if( rc!=SQLITE_OK ){ - Tcl_AppendResult(interp, sqlite_error_string(rc), 0); + Tcl_AppendResult(interp, sqlite3_error_string(rc), 0); rc = TCL_ERROR; } break; @@ -925,7 +925,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ #ifdef SQLITE_HAS_CODEC rc = sqlite_rekey(pDb->db, pKey, nKey); if( rc ){ - Tcl_AppendResult(interp, sqlite_error_string(rc), 0); + Tcl_AppendResult(interp, sqlite3_error_string(rc), 0); rc = TCL_ERROR; } #endif @@ -944,7 +944,7 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ return TCL_ERROR; } if( Tcl_GetIntFromObj(interp, objv[2], &ms) ) return TCL_ERROR; - sqlite_busy_timeout(pDb->db, ms); + sqlite3_busy_timeout(pDb->db, ms); break; } @@ -976,9 +976,9 @@ static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ } if( pDb->zTrace ){ pDb->interp = interp; - sqlite_trace(pDb->db, DbTraceHandler, pDb); + sqlite3_trace(pDb->db, DbTraceHandler, pDb); }else{ - sqlite_trace(pDb->db, 0, 0); + sqlite3_trace(pDb->db, 0, 0); } } break; @@ -1031,11 +1031,11 @@ static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ if( objc==2 ){ zArg = Tcl_GetStringFromObj(objv[1], 0); if( strcmp(zArg,"-encoding")==0 ){ - Tcl_AppendResult(interp,sqlite_encoding,0); + Tcl_AppendResult(interp,sqlite3_encoding,0); return TCL_OK; } if( strcmp(zArg,"-version")==0 ){ - Tcl_AppendResult(interp,sqlite_version,0); + Tcl_AppendResult(interp,sqlite3_version,0); return TCL_OK; } if( strcmp(zArg,"-has-codec")==0 ){ @@ -1086,9 +1086,9 @@ static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ memset(p, 0, sizeof(*p)); zFile = Tcl_GetStringFromObj(objv[2], 0); #ifdef SQLITE_HAS_CODEC - p->db = sqlite_open_encrypted(zFile, pKey, nKey, 0, &zErrMsg); + p->db = sqlite3_open_encrypted(zFile, pKey, nKey, 0, &zErrMsg); #else - p->db = sqlite_open(zFile, mode, &zErrMsg); + p->db = sqlite3_open(zFile, mode, &zErrMsg); #endif if( p->db==0 ){ Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE); diff --git a/src/test1.c b/src/test1.c index 3436bc75c..109beb979 100644 --- a/src/test1.c +++ b/src/test1.c @@ -13,7 +13,7 @@ ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** -** $Id: test1.c,v 1.37 2004/05/08 08:23:39 danielk1977 Exp $ +** $Id: test1.c,v 1.38 2004/05/10 10:34:53 danielk1977 Exp $ */ #include "sqliteInt.h" #include "tcl.h" @@ -82,7 +82,7 @@ static int makePointerStr(Tcl_Interp *interp, char *zPtr, void *p){ } /* -** Usage: sqlite_open filename +** Usage: sqlite3_open filename ** ** Returns: The name of an open database. */ @@ -100,7 +100,7 @@ static int sqlite_test_open( " FILENAME\"", 0); return TCL_ERROR; } - db = sqlite_open(argv[1], 0666, &zErr); + db = sqlite3_open(argv[1], 0666, &zErr); if( db==0 ){ Tcl_AppendResult(interp, zErr, 0); free(zErr); @@ -112,7 +112,7 @@ static int sqlite_test_open( } /* -** The callback routine for sqlite_exec_printf(). +** The callback routine for sqlite3_exec_printf(). */ static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){ Tcl_DString *str = (Tcl_DString*)pArg; @@ -130,9 +130,9 @@ static int exec_printf_cb(void *pArg, int argc, char **argv, char **name){ } /* -** Usage: sqlite_exec_printf DB FORMAT STRING +** Usage: sqlite3_exec_printf DB FORMAT STRING ** -** Invoke the sqlite_exec_printf() interface using the open database +** Invoke the sqlite3_exec_printf() interface using the open database ** DB. The SQL is the string FORMAT. The format string should contain ** one %s or %q. STRING is the value inserted into %s or %q. */ @@ -154,7 +154,7 @@ static int test_exec_printf( } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; Tcl_DStringInit(&str); - rc = sqlite_exec_printf(db, argv[2], exec_printf_cb, &str, &zErr, argv[3]); + rc = sqlite3_exec_printf(db, argv[2], exec_printf_cb, &str, &zErr, argv[3]); sprintf(zBuf, "%d", rc); Tcl_AppendElement(interp, zBuf); Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr); @@ -164,7 +164,7 @@ static int test_exec_printf( } /* -** Usage: sqlite_mprintf_z_test SEPARATOR ARG0 ARG1 ... +** Usage: sqlite3_mprintf_z_test SEPARATOR ARG0 ARG1 ... ** ** Test the %z format of mprintf(). Use multiple mprintf() calls to ** concatenate arg0 through argn using separator as the separator. @@ -188,9 +188,9 @@ static int test_mprintf_z( } /* -** Usage: sqlite_get_table_printf DB FORMAT STRING +** Usage: sqlite3_get_table_printf DB FORMAT STRING ** -** Invoke the sqlite_get_table_printf() interface using the open database +** Invoke the sqlite3_get_table_printf() interface using the open database ** DB. The SQL is the string FORMAT. The format string should contain ** one %s or %q. STRING is the value inserted into %s or %q. */ @@ -215,7 +215,7 @@ static int test_get_table_printf( } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; Tcl_DStringInit(&str); - rc = sqlite_get_table_printf(db, argv[2], &aResult, &nRow, &nCol, + rc = sqlite3_get_table_printf(db, argv[2], &aResult, &nRow, &nCol, &zErr, argv[3]); sprintf(zBuf, "%d", rc); Tcl_AppendElement(interp, zBuf); @@ -230,14 +230,14 @@ static int test_get_table_printf( }else{ Tcl_AppendElement(interp, zErr); } - sqlite_free_table(aResult); + sqlite3_free_table(aResult); if( zErr ) free(zErr); return TCL_OK; } /* -** Usage: sqlite_last_insert_rowid DB +** Usage: sqlite3_last_insert_rowid DB ** ** Returns the integer ROWID of the most recent insert. */ @@ -255,15 +255,15 @@ static int test_last_rowid( return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; - sprintf(zBuf, "%d", sqlite_last_insert_rowid(db)); + sprintf(zBuf, "%d", sqlite3_last_insert_rowid(db)); Tcl_AppendResult(interp, zBuf, 0); return SQLITE_OK; } /* -** Usage: sqlite_close DB +** Usage: sqlite3_close DB ** -** Closes the database opened by sqlite_open. +** Closes the database opened by sqlite3_open. */ static int sqlite_test_close( void *NotUsed, @@ -278,7 +278,7 @@ static int sqlite_test_close( return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; - sqlite_close(db); + sqlite3_close(db); return TCL_OK; } @@ -290,7 +290,7 @@ static void ifnullFunc(sqlite_func *context, int argc, const char **argv){ int i; for(i=0; i<argc; i++){ if( argv[i] ){ - sqlite_set_result_string(context, argv[i], -1); + sqlite3_set_result_string(context, argv[i], -1); break; } } @@ -345,11 +345,11 @@ static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){ } /* -** Implementation of the x_sqlite_exec() function. This function takes +** Implementation of the x_sqlite3_exec() function. This function takes ** a single argument and attempts to execute that argument as SQL code. ** This is illegal and should set the SQLITE_MISUSE flag on the database. ** -** 2004-Jan-07: We have changed this to make it legal to call sqlite_exec() +** 2004-Jan-07: We have changed this to make it legal to call sqlite3_exec() ** from within a function call. ** ** This routine simulates the effect of having two threads attempt to @@ -358,25 +358,25 @@ static int execFuncCallback(void *pData, int argc, char **argv, char **NotUsed){ static void sqlite3ExecFunc(sqlite_func *context, int argc, const char **argv){ struct dstr x; memset(&x, 0, sizeof(x)); - sqlite_exec((sqlite*)sqlite_user_data(context), argv[0], + sqlite3_exec((sqlite*)sqlite3_user_data(context), argv[0], execFuncCallback, &x, 0); - sqlite_set_result_string(context, x.z, x.nUsed); + sqlite3_set_result_string(context, x.z, x.nUsed); sqliteFree(x.z); } /* ** Usage: sqlite_test_create_function DB ** -** Call the sqlite_create_function API on the given database in order +** Call the sqlite3_create_function API on the given database in order ** to create a function named "x_coalesce". This function does the same thing ** as the "coalesce" function. This function also registers an SQL function -** named "x_sqlite_exec" that invokes sqlite_exec(). Invoking sqlite_exec() +** named "x_sqlite3_exec" that invokes sqlite3_exec(). Invoking sqlite3_exec() ** in this way is illegal recursion and should raise an SQLITE_MISUSE error. ** The effect is similar to trying to use the same database connection from ** two threads at the same time. ** ** The original motivation for this routine was to be able to call the -** sqlite_create_function function while a query is in progress in order +** sqlite3_create_function function while a query is in progress in order ** to test the SQLITE_MISUSE detection logic. */ static int test_create_function( @@ -393,8 +393,8 @@ static int test_create_function( return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; - sqlite_create_function(db, "x_coalesce", -1, ifnullFunc, 0); - sqlite_create_function(db, "x_sqlite_exec", 1, sqlite3ExecFunc, db); + sqlite3_create_function(db, "x_coalesce", -1, ifnullFunc, 0); + sqlite3_create_function(db, "x_sqlite3_exec", 1, sqlite3ExecFunc, db); return TCL_OK; } @@ -407,26 +407,26 @@ struct CountCtx { }; static void countStep(sqlite_func *context, int argc, const char **argv){ CountCtx *p; - p = sqlite_aggregate_context(context, sizeof(*p)); + p = sqlite3_aggregate_context(context, sizeof(*p)); if( (argc==0 || argv[0]) && p ){ p->n++; } } static void countFinalize(sqlite_func *context){ CountCtx *p; - p = sqlite_aggregate_context(context, sizeof(*p)); - sqlite_set_result_int(context, p ? p->n : 0); + p = sqlite3_aggregate_context(context, sizeof(*p)); + sqlite3_set_result_int(context, p ? p->n : 0); } /* ** Usage: sqlite_test_create_aggregate DB ** -** Call the sqlite_create_function API on the given database in order +** Call the sqlite3_create_function API on the given database in order ** to create a function named "x_count". This function does the same thing ** as the "md5sum" function. ** ** The original motivation for this routine was to be able to call the -** sqlite_create_aggregate function while a query is in progress in order +** sqlite3_create_aggregate function while a query is in progress in order ** to test the SQLITE_MISUSE detection logic. */ static int test_create_aggregate( @@ -442,19 +442,19 @@ static int test_create_aggregate( return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; - sqlite_create_aggregate(db, "x_count", 0, countStep, countFinalize, 0); - sqlite_create_aggregate(db, "x_count", 1, countStep, countFinalize, 0); + sqlite3_create_aggregate(db, "x_count", 0, countStep, countFinalize, 0); + sqlite3_create_aggregate(db, "x_count", 1, countStep, countFinalize, 0); return TCL_OK; } /* -** Usage: sqlite_mprintf_int FORMAT INTEGER INTEGER INTEGER +** Usage: sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER ** ** Call mprintf with three integer arguments */ -static int sqlite_mprintf_int( +static int sqlite3_mprintf_int( void *NotUsed, Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int argc, /* Number of arguments */ @@ -470,18 +470,18 @@ static int sqlite_mprintf_int( for(i=2; i<5; i++){ if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR; } - z = sqlite_mprintf(argv[1], a[0], a[1], a[2]); + z = sqlite3_mprintf(argv[1], a[0], a[1], a[2]); Tcl_AppendResult(interp, z, 0); - sqlite_freemem(z); + sqlite3_freemem(z); return TCL_OK; } /* -** Usage: sqlite_mprintf_str FORMAT INTEGER INTEGER STRING +** Usage: sqlite3_mprintf_str FORMAT INTEGER INTEGER STRING ** ** Call mprintf with two integer arguments and one string argument */ -static int sqlite_mprintf_str( +static int sqlite3_mprintf_str( void *NotUsed, Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int argc, /* Number of arguments */ @@ -497,18 +497,18 @@ static int sqlite_mprintf_str( for(i=2; i<4; i++){ if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR; } - z = sqlite_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL); + z = sqlite3_mprintf(argv[1], a[0], a[1], argc>4 ? argv[4] : NULL); Tcl_AppendResult(interp, z, 0); - sqlite_freemem(z); + sqlite3_freemem(z); return TCL_OK; } /* -** Usage: sqlite_mprintf_str FORMAT INTEGER INTEGER DOUBLE +** Usage: sqlite3_mprintf_str FORMAT INTEGER INTEGER DOUBLE ** ** Call mprintf with two integer arguments and one double argument */ -static int sqlite_mprintf_double( +static int sqlite3_mprintf_double( void *NotUsed, Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int argc, /* Number of arguments */ @@ -526,20 +526,20 @@ static int sqlite_mprintf_double( if( Tcl_GetInt(interp, argv[i], &a[i-2]) ) return TCL_ERROR; } if( Tcl_GetDouble(interp, argv[4], &r) ) return TCL_ERROR; - z = sqlite_mprintf(argv[1], a[0], a[1], r); + z = sqlite3_mprintf(argv[1], a[0], a[1], r); Tcl_AppendResult(interp, z, 0); - sqlite_freemem(z); + sqlite3_freemem(z); return TCL_OK; } /* -** Usage: sqlite_mprintf_str FORMAT DOUBLE DOUBLE +** Usage: sqlite3_mprintf_str FORMAT DOUBLE DOUBLE ** ** Call mprintf with a single double argument which is the product of the ** two arguments given above. This is used to generate overflow and underflow ** doubles to test that they are converted properly. */ -static int sqlite_mprintf_scaled( +static int sqlite3_mprintf_scaled( void *NotUsed, Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int argc, /* Number of arguments */ @@ -556,9 +556,9 @@ static int sqlite_mprintf_scaled( for(i=2; i<4; i++){ if( Tcl_GetDouble(interp, argv[i], &r[i-2]) ) return TCL_ERROR; } - z = sqlite_mprintf(argv[1], r[0]*r[1]); + z = sqlite3_mprintf(argv[1], r[0]*r[1]); Tcl_AppendResult(interp, z, 0); - sqlite_freemem(z); + sqlite3_freemem(z); return TCL_OK; } @@ -566,7 +566,7 @@ static int sqlite_mprintf_scaled( ** Usage: sqlite_malloc_fail N ** ** Rig sqliteMalloc() to fail on the N-th call. Turn off this mechanism -** and reset the sqlite_malloc_failed variable is N==0. +** and reset the sqlite3_malloc_failed variable is N==0. */ #ifdef MEMORY_DEBUG static int sqlite_malloc_fail( @@ -581,8 +581,8 @@ static int sqlite_malloc_fail( return TCL_ERROR; } if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR; - sqlite_iMallocFail = n; - sqlite_malloc_failed = 0; + sqlite3_iMallocFail = n; + sqlite3_malloc_failed = 0; return TCL_OK; } #endif @@ -600,7 +600,7 @@ static int sqlite_malloc_stat( char **argv /* Text of each argument */ ){ char zBuf[200]; - sprintf(zBuf, "%d %d %d", sqlite_nMalloc, sqlite_nFree, sqlite_iMallocFail); + sprintf(zBuf, "%d %d %d", sqlite3_nMalloc, sqlite3_nFree, sqlite3_iMallocFail); Tcl_AppendResult(interp, zBuf, 0); return TCL_OK; } @@ -630,19 +630,19 @@ static int sqlite_abort( static void testFunc(sqlite_func *context, int argc, const char **argv){ while( argc>=2 ){ if( argv[0]==0 ){ - sqlite_set_result_error(context, "first argument to test function " + sqlite3_set_result_error(context, "first argument to test function " "may not be NULL", -1); }else if( sqlite3StrICmp(argv[0],"string")==0 ){ - sqlite_set_result_string(context, argv[1], -1); + sqlite3_set_result_string(context, argv[1], -1); }else if( argv[1]==0 ){ - sqlite_set_result_error(context, "2nd argument may not be NULL if the " + sqlite3_set_result_error(context, "2nd argument may not be NULL if the " "first argument is not \"string\"", -1); }else if( sqlite3StrICmp(argv[0],"int")==0 ){ - sqlite_set_result_int(context, atoi(argv[1])); + sqlite3_set_result_int(context, atoi(argv[1])); }else if( sqlite3StrICmp(argv[0],"double")==0 ){ - sqlite_set_result_double(context, sqlite3AtoF(argv[1], 0)); + sqlite3_set_result_double(context, sqlite3AtoF(argv[1], 0)); }else{ - sqlite_set_result_error(context,"first argument should be one of: " + sqlite3_set_result_error(context,"first argument should be one of: " "string int double", -1); } argc -= 2; @@ -669,9 +669,9 @@ static int test_register_func( return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; - rc = sqlite_create_function(db, argv[2], -1, testFunc, 0); + rc = sqlite3_create_function(db, argv[2], -1, testFunc, 0); if( rc!=0 ){ - Tcl_AppendResult(interp, sqlite_error_string(rc), 0); + Tcl_AppendResult(interp, sqlite3_error_string(rc), 0); return TCL_ERROR; } return TCL_OK; @@ -722,16 +722,16 @@ static int sqlite_datatypes( return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; - rc = sqlite_exec(db, argv[2], rememberDataTypes, interp, 0); + rc = sqlite3_exec(db, argv[2], rememberDataTypes, interp, 0); if( rc!=0 && rc!=SQLITE_ABORT ){ - Tcl_AppendResult(interp, sqlite_error_string(rc), 0); + Tcl_AppendResult(interp, sqlite3_error_string(rc), 0); return TCL_ERROR; } return TCL_OK; } /* -** Usage: sqlite_compile DB SQL ?TAILVAR? +** Usage: sqlite3_compile DB SQL ?TAILVAR? ** ** Attempt to compile an SQL statement. Return a pointer to the virtual ** machine used to execute that statement. Unprocessed SQL is written @@ -755,13 +755,13 @@ static int test_compile( return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; - rc = sqlite_compile(db, argv[2], argc==4 ? &zTail : 0, &vm, &zErr); + rc = sqlite3_compile(db, argv[2], argc==4 ? &zTail : 0, &vm, &zErr); if( argc==4 ) Tcl_SetVar(interp, argv[3], zTail, 0); if( rc ){ assert( vm==0 ); sprintf(zBuf, "(%d) ", rc); Tcl_AppendResult(interp, zBuf, zErr, 0); - sqlite_freemem(zErr); + sqlite3_freemem(zErr); return TCL_ERROR; } if( vm ){ @@ -772,7 +772,7 @@ static int test_compile( } /* -** Usage: sqlite_step VM ?NVAR? ?VALUEVAR? ?COLNAMEVAR? +** Usage: sqlite3_step VM ?NVAR? ?VALUEVAR? ?COLNAMEVAR? ** ** Step a virtual machine. Return a the result code as a string. ** Column results are written into three variables. @@ -796,7 +796,7 @@ static int test_step( return TCL_ERROR; } if( getVmPointer(interp, argv[1], &vm) ) return TCL_ERROR; - rc = sqlite_step(vm, argc>=3?&N:0, argc>=4?&azValue:0, argc==5?&azColName:0); + rc = sqlite3_step(vm, argc>=3?&N:0, argc>=4?&azValue:0, argc==5?&azColName:0); if( argc>=3 ){ sprintf(zBuf, "%d", N); Tcl_SetVar(interp, argv[2], zBuf, 0); @@ -832,7 +832,7 @@ static int test_step( } /* -** Usage: sqlite_finalize VM +** Usage: sqlite3_finalize VM ** ** Shutdown a virtual machine. */ @@ -851,19 +851,19 @@ static int test_finalize( return TCL_ERROR; } if( getVmPointer(interp, argv[1], &vm) ) return TCL_ERROR; - rc = sqlite_finalize(vm, &zErrMsg); + rc = sqlite3_finalize(vm, &zErrMsg); if( rc ){ char zBuf[50]; sprintf(zBuf, "(%d) ", rc); Tcl_AppendResult(interp, zBuf, zErrMsg, 0); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); return TCL_ERROR; } return TCL_OK; } /* -** Usage: sqlite_reset VM +** Usage: sqlite3_reset VM ** ** Reset a virtual machine and prepare it to be run again. */ @@ -882,12 +882,12 @@ static int test_reset( return TCL_ERROR; } if( getVmPointer(interp, argv[1], &vm) ) return TCL_ERROR; - rc = sqlite_reset(vm, &zErrMsg); + rc = sqlite3_reset(vm, &zErrMsg); if( rc ){ char zBuf[50]; sprintf(zBuf, "(%d) ", rc); Tcl_AppendResult(interp, zBuf, zErrMsg, 0); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); return TCL_ERROR; } return TCL_OK; @@ -895,12 +895,12 @@ static int test_reset( /* ** This is the "static_bind_value" that variables are bound to when -** the FLAG option of sqlite_bind is "static" +** the FLAG option of sqlite3_bind is "static" */ static char *sqlite_static_bind_value = 0; /* -** Usage: sqlite_bind VM IDX VALUE FLAGS +** Usage: sqlite3_bind VM IDX VALUE FLAGS ** ** Sets the value of the IDX-th occurance of "?" in the original SQL ** string. VALUE is the new value. If FLAGS=="null" then VALUE is @@ -926,11 +926,11 @@ static int test_bind( if( getVmPointer(interp, argv[1], &vm) ) return TCL_ERROR; if( Tcl_GetInt(interp, argv[2], &idx) ) return TCL_ERROR; if( strcmp(argv[4],"null")==0 ){ - rc = sqlite_bind(vm, idx, 0, 0, 0); + rc = sqlite3_bind(vm, idx, 0, 0, 0); }else if( strcmp(argv[4],"static")==0 ){ - rc = sqlite_bind(vm, idx, sqlite_static_bind_value, -1, 0); + rc = sqlite3_bind(vm, idx, sqlite_static_bind_value, -1, 0); }else if( strcmp(argv[4],"normal")==0 ){ - rc = sqlite_bind(vm, idx, argv[3], -1, 1); + rc = sqlite3_bind(vm, idx, argv[3], -1, 1); }else{ Tcl_AppendResult(interp, "4th argument should be " "\"null\" or \"static\" or \"normal\"", 0); @@ -939,7 +939,7 @@ static int test_bind( if( rc ){ char zBuf[50]; sprintf(zBuf, "(%d) ", rc); - Tcl_AppendResult(interp, zBuf, sqlite_error_string(rc), 0); + Tcl_AppendResult(interp, zBuf, sqlite3_error_string(rc), 0); return TCL_ERROR; } return TCL_OK; @@ -971,26 +971,26 @@ static int test_breakpoint( ** Register commands with the TCL interpreter. */ int Sqlitetest1_Init(Tcl_Interp *interp){ - extern int sqlite_search_count; - extern int sqlite_interrupt_count; - extern int sqlite_open_file_count; - extern int sqlite_current_time; + extern int sqlite3_search_count; + extern int sqlite3_interrupt_count; + extern int sqlite3_open_file_count; + extern int sqlite3_current_time; static struct { char *zName; Tcl_CmdProc *xProc; } aCmd[] = { - { "sqlite_mprintf_int", (Tcl_CmdProc*)sqlite_mprintf_int }, - { "sqlite_mprintf_str", (Tcl_CmdProc*)sqlite_mprintf_str }, - { "sqlite_mprintf_double", (Tcl_CmdProc*)sqlite_mprintf_double }, - { "sqlite_mprintf_scaled", (Tcl_CmdProc*)sqlite_mprintf_scaled }, - { "sqlite_mprintf_z_test", (Tcl_CmdProc*)test_mprintf_z }, - { "sqlite_open", (Tcl_CmdProc*)sqlite_test_open }, - { "sqlite_last_insert_rowid", (Tcl_CmdProc*)test_last_rowid }, - { "sqlite_exec_printf", (Tcl_CmdProc*)test_exec_printf }, - { "sqlite_get_table_printf", (Tcl_CmdProc*)test_get_table_printf }, - { "sqlite_close", (Tcl_CmdProc*)sqlite_test_close }, - { "sqlite_create_function", (Tcl_CmdProc*)test_create_function }, - { "sqlite_create_aggregate", (Tcl_CmdProc*)test_create_aggregate }, + { "sqlite3_mprintf_int", (Tcl_CmdProc*)sqlite3_mprintf_int }, + { "sqlite3_mprintf_str", (Tcl_CmdProc*)sqlite3_mprintf_str }, + { "sqlite3_mprintf_double", (Tcl_CmdProc*)sqlite3_mprintf_double }, + { "sqlite3_mprintf_scaled", (Tcl_CmdProc*)sqlite3_mprintf_scaled }, + { "sqlite3_mprintf_z_test", (Tcl_CmdProc*)test_mprintf_z }, + { "sqlite3_open", (Tcl_CmdProc*)sqlite_test_open }, + { "sqlite3_last_insert_rowid", (Tcl_CmdProc*)test_last_rowid }, + { "sqlite3_exec_printf", (Tcl_CmdProc*)test_exec_printf }, + { "sqlite3_get_table_printf", (Tcl_CmdProc*)test_get_table_printf }, + { "sqlite3_close", (Tcl_CmdProc*)sqlite_test_close }, + { "sqlite3_create_function", (Tcl_CmdProc*)test_create_function }, + { "sqlite3_create_aggregate", (Tcl_CmdProc*)test_create_aggregate }, { "sqlite_register_test_function", (Tcl_CmdProc*)test_register_func }, { "sqlite_abort", (Tcl_CmdProc*)sqlite_abort }, { "sqlite_datatypes", (Tcl_CmdProc*)sqlite_datatypes }, @@ -998,11 +998,11 @@ int Sqlitetest1_Init(Tcl_Interp *interp){ { "sqlite_malloc_fail", (Tcl_CmdProc*)sqlite_malloc_fail }, { "sqlite_malloc_stat", (Tcl_CmdProc*)sqlite_malloc_stat }, #endif - { "sqlite_compile", (Tcl_CmdProc*)test_compile }, - { "sqlite_step", (Tcl_CmdProc*)test_step }, - { "sqlite_finalize", (Tcl_CmdProc*)test_finalize }, - { "sqlite_bind", (Tcl_CmdProc*)test_bind }, - { "sqlite_reset", (Tcl_CmdProc*)test_reset }, + { "sqlite3_compile", (Tcl_CmdProc*)test_compile }, + { "sqlite3_step", (Tcl_CmdProc*)test_step }, + { "sqlite3_finalize", (Tcl_CmdProc*)test_finalize }, + { "sqlite3_bind", (Tcl_CmdProc*)test_bind }, + { "sqlite3_reset", (Tcl_CmdProc*)test_reset }, { "breakpoint", (Tcl_CmdProc*)test_breakpoint }, }; int i; @@ -1010,14 +1010,14 @@ int Sqlitetest1_Init(Tcl_Interp *interp){ for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); } - Tcl_LinkVar(interp, "sqlite_search_count", - (char*)&sqlite_search_count, TCL_LINK_INT); - Tcl_LinkVar(interp, "sqlite_interrupt_count", - (char*)&sqlite_interrupt_count, TCL_LINK_INT); - Tcl_LinkVar(interp, "sqlite_open_file_count", - (char*)&sqlite_open_file_count, TCL_LINK_INT); - Tcl_LinkVar(interp, "sqlite_current_time", - (char*)&sqlite_current_time, TCL_LINK_INT); + Tcl_LinkVar(interp, "sqlite3_search_count", + (char*)&sqlite3_search_count, TCL_LINK_INT); + Tcl_LinkVar(interp, "sqlite3_interrupt_count", + (char*)&sqlite3_interrupt_count, TCL_LINK_INT); + Tcl_LinkVar(interp, "sqlite3_open_file_count", + (char*)&sqlite3_open_file_count, TCL_LINK_INT); + Tcl_LinkVar(interp, "sqlite3_current_time", + (char*)&sqlite3_current_time, TCL_LINK_INT); Tcl_LinkVar(interp, "sqlite_static_bind_value", (char*)&sqlite_static_bind_value, TCL_LINK_STRING); return TCL_OK; diff --git a/src/test2.c b/src/test2.c index 13a7dae82..72b68c56b 100644 --- a/src/test2.c +++ b/src/test2.c @@ -13,7 +13,7 @@ ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** -** $Id: test2.c,v 1.18 2004/05/08 08:23:39 danielk1977 Exp $ +** $Id: test2.c,v 1.19 2004/05/10 10:34:53 danielk1977 Exp $ */ #include "os.h" #include "sqliteInt.h" @@ -524,7 +524,7 @@ static int fake_big_file( ** Register commands with the TCL interpreter. */ int Sqlitetest2_Init(Tcl_Interp *interp){ - extern int sqlite_io_error_pending; + extern int sqlite3_io_error_pending; char zBuf[100]; static struct { char *zName; @@ -551,8 +551,8 @@ int Sqlitetest2_Init(Tcl_Interp *interp){ for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); } - Tcl_LinkVar(interp, "sqlite_io_error_pending", - (char*)&sqlite_io_error_pending, TCL_LINK_INT); + Tcl_LinkVar(interp, "sqlite3_io_error_pending", + (char*)&sqlite3_io_error_pending, TCL_LINK_INT); #ifdef SQLITE_TEST { extern int journal_format; diff --git a/src/test4.c b/src/test4.c index b1161e81b..c547ea11d 100644 --- a/src/test4.c +++ b/src/test4.c @@ -11,7 +11,7 @@ ************************************************************************* ** Code for testing the the SQLite library in a multithreaded environment. ** -** $Id: test4.c,v 1.4 2004/05/08 08:23:39 danielk1977 Exp $ +** $Id: test4.c,v 1.5 2004/05/10 10:34:53 danielk1977 Exp $ */ #include "sqliteInt.h" #include "tcl.h" @@ -63,15 +63,15 @@ static Thread threadset[N_THREAD]; static void *thread_main(void *pArg){ Thread *p = (Thread*)pArg; if( p->db ){ - sqlite_close(p->db); + sqlite3_close(p->db); } - p->db = sqlite_open(p->zFilename, 0, &p->zErr); + p->db = sqlite3_open(p->zFilename, 0, &p->zErr); p->vm = 0; p->completed = 1; while( p->opnum<=p->completed ) sched_yield(); while( p->xOp ){ if( p->zErr && p->zErr!=p->zStaticErr ){ - sqlite_freemem(p->zErr); + sqlite3_freemem(p->zErr); p->zErr = 0; } (*p->xOp)(p); @@ -79,15 +79,15 @@ static void *thread_main(void *pArg){ while( p->opnum<=p->completed ) sched_yield(); } if( p->vm ){ - sqlite_finalize(p->vm, 0); + sqlite3_finalize(p->vm, 0); p->vm = 0; } if( p->db ){ - sqlite_close(p->db); + sqlite3_close(p->db); p->db = 0; } if( p->zErr && p->zErr!=p->zStaticErr ){ - sqlite_freemem(p->zErr); + sqlite3_freemem(p->zErr); p->zErr = 0; } p->completed++; @@ -441,10 +441,10 @@ static void do_compile(Thread *p){ return; } if( p->vm ){ - sqlite_finalize(p->vm, 0); + sqlite3_finalize(p->vm, 0); p->vm = 0; } - p->rc = sqlite_compile(p->db, p->zArg, 0, &p->vm, &p->zErr); + p->rc = sqlite3_compile(p->db, p->zArg, 0, &p->vm, &p->zErr); } /* @@ -487,7 +487,7 @@ static void do_step(Thread *p){ p->rc = SQLITE_ERROR; return; } - p->rc = sqlite_step(p->vm, &p->argc, &p->argv, &p->colv); + p->rc = sqlite3_step(p->vm, &p->argc, &p->argv, &p->colv); } /* @@ -528,7 +528,7 @@ static void do_finalize(Thread *p){ p->rc = SQLITE_ERROR; return; } - p->rc = sqlite_finalize(p->vm, &p->zErr); + p->rc = sqlite3_finalize(p->vm, &p->zErr); p->vm = 0; } diff --git a/src/tokenize.c b/src/tokenize.c index 065d1b408..4ccc98f65 100644 --- a/src/tokenize.c +++ b/src/tokenize.c @@ -15,7 +15,7 @@ ** individual tokens and sends those tokens one-by-one over to the ** parser for analysis. ** -** $Id: tokenize.c,v 1.69 2004/05/08 08:23:39 danielk1977 Exp $ +** $Id: tokenize.c,v 1.70 2004/05/10 10:34:53 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -416,7 +416,7 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){ } pParse->sLastToken.dyn = 0; pParse->zTail = zSql; - while( sqlite_malloc_failed==0 && zSql[i]!=0 ){ + while( sqlite3_malloc_failed==0 && zSql[i]!=0 ){ assert( i>=0 ); pParse->sLastToken.z = &zSql[i]; assert( pParse->sLastToken.dyn==0 ); @@ -462,7 +462,7 @@ abort_parse: } sqlite3ParserFree(pEngine, free); if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){ - sqlite3SetString(&pParse->zErrMsg, sqlite_error_string(pParse->rc), + sqlite3SetString(&pParse->zErrMsg, sqlite3_error_string(pParse->rc), (char*)0); } if( pParse->zErrMsg ){ @@ -493,7 +493,7 @@ abort_parse: } /* -** Token types used by the sqlite_complete() routine. See the header +** Token types used by the sqlite3_complete() routine. See the header ** comments on that procedure for additional information. */ #define tkEXPLAIN 0 @@ -551,7 +551,7 @@ abort_parse: ** ** Whitespace never causes a state transition and is always ignored. */ -int sqlite_complete(const char *zSql){ +int sqlite3_complete(const char *zSql){ u8 state = 0; /* Current state, using numbers defined in header comment */ u8 token; /* Value of the next token */ diff --git a/src/trigger.c b/src/trigger.c index d15225583..985b0b43c 100644 --- a/src/trigger.c +++ b/src/trigger.c @@ -63,7 +63,7 @@ void sqlite3BeginTrigger( ** 4. That we are not trying to create an INSTEAD OF trigger on a table. ** 5. That we are not trying to create a BEFORE or AFTER trigger on a view. */ - if( sqlite_malloc_failed ) goto trigger_cleanup; + if( sqlite3_malloc_failed ) goto trigger_cleanup; assert( pTableName->nSrc==1 ); if( db->init.busy && sqlite3FixInit(&sFix, pParse, db->init.iDb, "trigger", pName) @@ -133,7 +133,7 @@ void sqlite3BeginTrigger( nt->name = zName; zName = 0; nt->table = sqliteStrDup(pTableName->a[0].zName); - if( sqlite_malloc_failed ) goto trigger_cleanup; + if( sqlite3_malloc_failed ) goto trigger_cleanup; nt->iDb = iDb; nt->iTabDb = tab->iDb; nt->op = op; @@ -234,10 +234,10 @@ triggerfinish_cleanup: ** the effect of copying all Expr.token.z values into memory obtained ** from sqliteMalloc(). As initially created, the Expr.token.z values ** all point to the input string that was fed to the parser. But that -** string is ephemeral - it will go away as soon as the sqlite_exec() +** string is ephemeral - it will go away as soon as the sqlite3_exec() ** call that started the parser exits. This routine makes a persistent ** copy of all the Expr.token.z strings so that the TriggerStep structure -** will be valid even after the sqlite_exec() call returns. +** will be valid even after the sqlite3_exec() call returns. */ static void sqlitePersistTriggerStep(TriggerStep *p){ if( p->target.z ){ @@ -393,7 +393,7 @@ void sqlite3DropTrigger(Parse *pParse, SrcList *pName){ int nName; sqlite *db = pParse->db; - if( sqlite_malloc_failed ) goto drop_trigger_cleanup; + if( sqlite3_malloc_failed ) goto drop_trigger_cleanup; assert( pName->nSrc==1 ); zDb = pName->a[0].zDatabase; zName = pName->a[0].zName; diff --git a/src/update.c b/src/update.c index 128b6ed4d..71d893899 100644 --- a/src/update.c +++ b/src/update.c @@ -12,7 +12,7 @@ ** This file contains C code routines that are called by the parser ** to handle UPDATE statements. ** -** $Id: update.c,v 1.71 2004/05/08 08:23:40 danielk1977 Exp $ +** $Id: update.c,v 1.72 2004/05/10 10:35:00 danielk1977 Exp $ */ #include "sqliteInt.h" @@ -59,7 +59,7 @@ void sqlite3Update( int oldIdx = -1; /* index of trigger "old" temp table */ sContext.pParse = 0; - if( pParse->nErr || sqlite_malloc_failed ) goto update_cleanup; + if( pParse->nErr || sqlite3_malloc_failed ) goto update_cleanup; db = pParse->db; assert( pTabList->nSrc==1 ); diff --git a/src/util.c b/src/util.c index 420a7c207..3052116bb 100644 --- a/src/util.c +++ b/src/util.c @@ -14,7 +14,7 @@ ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** -** $Id: util.c,v 1.78 2004/05/10 10:05:54 danielk1977 Exp $ +** $Id: util.c,v 1.79 2004/05/10 10:35:00 danielk1977 Exp $ */ #include "sqliteInt.h" #include <stdarg.h> @@ -24,7 +24,7 @@ ** If malloc() ever fails, this global variable gets set to 1. ** This causes the library to abort and never again function. */ -int sqlite_malloc_failed = 0; +int sqlite3_malloc_failed = 0; /* ** If MEMORY_DEBUG is defined, then use versions of malloc() and @@ -36,9 +36,9 @@ int sqlite_malloc_failed = 0; ** For keeping track of the number of mallocs and frees. This ** is used to check for memory leaks. */ -int sqlite_nMalloc; /* Number of sqliteMalloc() calls */ -int sqlite_nFree; /* Number of sqliteFree() calls */ -int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ +int sqlite3_nMalloc; /* Number of sqliteMalloc() calls */ +int sqlite3_nFree; /* Number of sqliteFree() calls */ +int sqlite3_iMallocFail; /* Fail sqliteMalloc() after this many calls */ #if MEMORY_DEBUG>1 static int memcnt = 0; #endif @@ -56,15 +56,15 @@ void *sqlite3Malloc_(int n, int bZero, char *zFile, int line){ void *p; int *pi; int i, k; - if( sqlite_iMallocFail>=0 ){ - sqlite_iMallocFail--; - if( sqlite_iMallocFail==0 ){ - sqlite_malloc_failed++; + if( sqlite3_iMallocFail>=0 ){ + sqlite3_iMallocFail--; + if( sqlite3_iMallocFail==0 ){ + sqlite3_malloc_failed++; #if MEMORY_DEBUG>1 fprintf(stderr,"**** failed to allocate %d bytes at %s:%d\n", n, zFile,line); #endif - sqlite_iMallocFail--; + sqlite3_iMallocFail--; return 0; } } @@ -72,10 +72,10 @@ void *sqlite3Malloc_(int n, int bZero, char *zFile, int line){ k = (n+sizeof(int)-1)/sizeof(int); pi = malloc( (N_GUARD*2+1+k)*sizeof(int)); if( pi==0 ){ - sqlite_malloc_failed++; + sqlite3_malloc_failed++; return 0; } - sqlite_nMalloc++; + sqlite3_nMalloc++; for(i=0; i<N_GUARD; i++) pi[i] = 0xdead1122; pi[N_GUARD] = n; for(i=0; i<N_GUARD; i++) pi[k+1+N_GUARD+i] = 0xdead3344; @@ -118,7 +118,7 @@ void sqlite3Free_(void *p, char *zFile, int line){ int *pi, i, k, n; pi = p; pi -= N_GUARD+1; - sqlite_nFree++; + sqlite3_nFree++; for(i=0; i<N_GUARD; i++){ if( pi[i]!=0xdead1122 ){ fprintf(stderr,"Low-end memory corruption at 0x%x\n", (int)p); @@ -175,7 +175,7 @@ void *sqlite3Realloc_(void *oldP, int n, char *zFile, int line){ k = (n + sizeof(int) - 1)/sizeof(int); pi = malloc( (k+N_GUARD*2+1)*sizeof(int) ); if( pi==0 ){ - sqlite_malloc_failed++; + sqlite3_malloc_failed++; return 0; } for(i=0; i<N_GUARD; i++) pi[i] = 0xdead1122; @@ -208,7 +208,7 @@ void sqlite3StrRealloc(char **pz){ if( pz==0 || *pz==0 ) return; zNew = malloc( strlen(*pz) + 1 ); if( zNew==0 ){ - sqlite_malloc_failed++; + sqlite3_malloc_failed++; sqliteFree(*pz); *pz = 0; } @@ -252,7 +252,7 @@ char *sqlite3StrNDup_(const char *z, int n, char *zFile, int line){ void *sqliteMalloc(int n){ void *p; if( (p = malloc(n))==0 ){ - if( n>0 ) sqlite_malloc_failed++; + if( n>0 ) sqlite3_malloc_failed++; }else{ memset(p, 0, n); } @@ -266,7 +266,7 @@ void *sqliteMalloc(int n){ void *sqliteMallocRaw(int n){ void *p; if( (p = malloc(n))==0 ){ - if( n>0 ) sqlite_malloc_failed++; + if( n>0 ) sqlite3_malloc_failed++; } return p; } @@ -296,7 +296,7 @@ void *sqliteRealloc(void *p, int n){ } p2 = realloc(p, n); if( p2==0 ){ - sqlite_malloc_failed++; + sqlite3_malloc_failed++; } return p2; } @@ -1085,7 +1085,7 @@ sqlite3LikeCompare(const unsigned char *zPattern, const unsigned char *zString){ ** Ticket #202: If db->magic is not a valid open value, take care not ** to modify the db structure at all. It could be that db is a stale ** pointer. In other words, it could be that there has been a prior -** call to sqlite_close(db) and db has been deallocated. And we do +** call to sqlite3_close(db) and db has been deallocated. And we do ** not want to write into deallocated memory. */ int sqlite3SafetyOn(sqlite *db){ @@ -1118,8 +1118,8 @@ int sqlite3SafetyOff(sqlite *db){ } /* -** Check to make sure we are not currently executing an sqlite_exec(). -** If we are currently in an sqlite_exec(), return true and set +** Check to make sure we are not currently executing an sqlite3_exec(). +** If we are currently in an sqlite3_exec(), return true and set ** sqlite.magic to SQLITE_MAGIC_ERROR. This will cause a complete ** shutdown of the database. ** diff --git a/src/vacuum.c b/src/vacuum.c index 0822ac344..52ca39b09 100644 --- a/src/vacuum.c +++ b/src/vacuum.c @@ -14,7 +14,7 @@ ** Most of the code in this file may be omitted by defining the ** SQLITE_OMIT_VACUUM macro. ** -** $Id: vacuum.c,v 1.14 2004/05/08 08:23:40 danielk1977 Exp $ +** $Id: vacuum.c,v 1.15 2004/05/10 10:35:00 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -93,10 +93,10 @@ static int execsql(char **pzErrMsg, sqlite *db, const char *zSql){ int rc; /* printf("***** executing *****\n%s\n", zSql); */ - rc = sqlite_exec(db, zSql, 0, 0, &zErrMsg); + rc = sqlite3_exec(db, zSql, 0, 0, &zErrMsg); if( zErrMsg ){ sqlite3SetString(pzErrMsg, zErrMsg, (char*)0); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); } return rc; } @@ -153,10 +153,10 @@ static int vacuumCallback1(void *pArg, int argc, char **argv, char **NotUsed){ appendText(&p->s1, "SELECT * FROM ", -1); appendQuoted(&p->s1, argv[1]); p->zTable = argv[1]; - rc = sqlite_exec(p->dbOld, p->s1.z, vacuumCallback2, p, &zErrMsg); + rc = sqlite3_exec(p->dbOld, p->s1.z, vacuumCallback2, p, &zErrMsg); if( zErrMsg ){ sqlite3SetString(p->pzErrMsg, zErrMsg, (char*)0); - sqlite_freemem(zErrMsg); + sqlite3_freemem(zErrMsg); } } if( rc!=SQLITE_ABORT ) p->rc = rc; @@ -266,7 +266,7 @@ int sqlite3RunVacuum(char **pzErrMsg, sqlite *db){ } - dbNew = sqlite_open(zTemp, 0, &zErrMsg); + dbNew = sqlite3_open(zTemp, 0, &zErrMsg); if( dbNew==0 ){ sqlite3SetString(pzErrMsg, "unable to open a temporary database at ", zTemp, " - ", zErrMsg, (char*)0); @@ -285,10 +285,10 @@ int sqlite3RunVacuum(char **pzErrMsg, sqlite *db){ assert( strlen(zPragma[i])<100 ); sprintf(zBuf, "PRAGMA %s;", zPragma[i]); sVac.zPragma = zPragma[i]; - rc = sqlite_exec(db, zBuf, vacuumCallback3, &sVac, &zErrMsg); + rc = sqlite3_exec(db, zBuf, vacuumCallback3, &sVac, &zErrMsg); } if( rc==SQLITE_OK ){ - rc = sqlite_exec(db, + rc = sqlite3_exec(db, "SELECT type, name, sql FROM sqlite_master " "WHERE sql NOT NULL AND type!='view' " "UNION ALL " @@ -298,7 +298,7 @@ int sqlite3RunVacuum(char **pzErrMsg, sqlite *db){ } if( rc==SQLITE_OK ){ rc = sqlite3BtreeCopyFile(db->aDb[0].pBt, dbNew->aDb[0].pBt); - sqlite_exec(db, "COMMIT", 0, 0, 0); + sqlite3_exec(db, "COMMIT", 0, 0, 0); sqlite3ResetInternalSchema(db, 0); } @@ -307,13 +307,13 @@ end_of_vacuum: sqlite3SetString(pzErrMsg, "unable to vacuum database - ", zErrMsg, (char*)0); } - sqlite_exec(db, "ROLLBACK", 0, 0, 0); - if( dbNew ) sqlite_close(dbNew); + sqlite3_exec(db, "ROLLBACK", 0, 0, 0); + if( dbNew ) sqlite3_close(dbNew); sqlite3OsDelete(zTemp); sqliteFree(zTemp); sqliteFree(sVac.s1.z); sqliteFree(sVac.s2.z); - if( zErrMsg ) sqlite_freemem(zErrMsg); + if( zErrMsg ) sqlite3_freemem(zErrMsg); if( rc==SQLITE_ABORT ) sVac.rc = SQLITE_ERROR; return sVac.rc; #endif diff --git a/src/vdbe.c b/src/vdbe.c index b9b558d9f..4193a9bc2 100644 --- a/src/vdbe.c +++ b/src/vdbe.c @@ -43,7 +43,7 @@ ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** -** $Id: vdbe.c,v 1.272 2004/05/10 07:17:32 danielk1977 Exp $ +** $Id: vdbe.c,v 1.273 2004/05/10 10:35:00 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -57,7 +57,7 @@ ** working correctly. This variable has no function other than to ** help verify the correct operation of the library. */ -int sqlite_search_count = 0; +int sqlite3_search_count = 0; /* ** When this global variable is positive, it gets decremented once before @@ -67,7 +67,7 @@ int sqlite_search_count = 0; ** This facility is used for testing purposes only. It does not function ** in an ordinary build. */ -int sqlite_interrupt_count = 0; +int sqlite3_interrupt_count = 0; /* ** Advance the virtual machine to the next output row. @@ -77,11 +77,11 @@ int sqlite_interrupt_count = 0; ** ** SQLITE_BUSY means that the virtual machine attempted to open ** a locked database and there is no busy callback registered. -** Call sqlite_step() again to retry the open. *pN is set to 0 +** Call sqlite3_step() again to retry the open. *pN is set to 0 ** and *pazColName and *pazValue are both set to NULL. ** ** SQLITE_DONE means that the virtual machine has finished -** executing. sqlite_step() should not be called again on this +** executing. sqlite3_step() should not be called again on this ** virtual machine. *pN and *pazColName are set appropriately ** but *pazValue is set to NULL. ** @@ -95,7 +95,7 @@ int sqlite_interrupt_count = 0; ** ** SQLITE_ERROR means that a run-time error (such as a constraint ** violation) has occurred. The details of the error will be returned -** by the next call to sqlite_finalize(). sqlite_step() should not +** by the next call to sqlite3_finalize(). sqlite3_step() should not ** be called again on the VM. ** ** SQLITE_MISUSE means that the this routine was called inappropriately. @@ -104,7 +104,7 @@ int sqlite_interrupt_count = 0; ** SQLITE_DONE. Or it could be the case the the same database connection ** is being used simulataneously by two or more threads. */ -int sqlite_step( +int sqlite3_step( sqlite_vm *pVm, /* The virtual machine to execute */ int *pN, /* OUT: Number of columns in result */ const char ***pazValue, /* OUT: Column data */ @@ -197,9 +197,9 @@ static AggElem *_AggInFocus(Agg *p){ static int hardStringify(Mem *pStack){ int fg = pStack->flags; if( fg & MEM_Real ){ - sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r); + sqlite3_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r); }else if( fg & MEM_Int ){ - sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%d",pStack->i); + sqlite3_snprintf(sizeof(pStack->zShort),pStack->zShort,"%d",pStack->i); }else{ pStack->zShort[0] = 0; } @@ -439,7 +439,7 @@ __inline__ unsigned long long int hwtime(void){ /* ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the -** sqlite_interrupt() routine has been called. If it has been, then +** sqlite3_interrupt() routine has been called. If it has been, then ** processing of the VDBE program is interrupted. ** ** This macro added to every instruction that does a jump in order to @@ -504,7 +504,7 @@ int sqlite3VdbeExec( assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY ); p->rc = SQLITE_OK; assert( p->explain==0 ); - if( sqlite_malloc_failed ) goto no_mem; + if( sqlite3_malloc_failed ) goto no_mem; pTos = p->pTos; if( p->popStack ){ popStack(&pTos, p->popStack); @@ -532,10 +532,10 @@ int sqlite3VdbeExec( ** if we have a special test build. */ #ifdef SQLITE_TEST - if( sqlite_interrupt_count>0 ){ - sqlite_interrupt_count--; - if( sqlite_interrupt_count==0 ){ - sqlite_interrupt(db); + if( sqlite3_interrupt_count>0 ){ + sqlite3_interrupt_count--; + if( sqlite3_interrupt_count==0 ){ + sqlite3_interrupt(db); } } #endif @@ -645,7 +645,7 @@ case OP_Return: { ** Exit immediately. All open cursors, Lists, Sorts, etc are closed ** automatically. ** -** P1 is the result code returned by sqlite_exec(). For a normal +** P1 is the result code returned by sqlite3_exec(). For a normal ** halt, this should be SQLITE_OK (0). For errors, it can be some ** other value. If P1!=0 then P2 will determine whether or not to ** rollback the current transaction. Do not rollback if P2==OE_Fail. @@ -711,11 +711,11 @@ case OP_String: { /* Opcode: Variable P1 * * ** ** Push the value of variable P1 onto the stack. A variable is -** an unknown in the original SQL string as handed to sqlite_compile(). +** an unknown in the original SQL string as handed to sqlite3_compile(). ** Any occurance of the '?' character in the original SQL is considered ** a variable. Variables in the SQL string are number from left to ** right beginning with 1. The values of variables are set using the -** sqlite_bind() API. +** sqlite3_bind() API. */ case OP_Variable: { int j = pOp->p1 - 1; @@ -770,7 +770,7 @@ case OP_Dup: { pTos->z = pTos->zShort; }else if( (pTos->flags & MEM_Static)==0 ){ pTos->z = sqliteMallocRaw(pFrom->n); - if( sqlite_malloc_failed ) goto no_mem; + if( sqlite3_malloc_failed ) goto no_mem; memcpy(pTos->z, pFrom->z, pFrom->n); pTos->flags &= ~(MEM_Static|MEM_Ephem|MEM_Short); pTos->flags |= MEM_Dyn; @@ -2441,7 +2441,7 @@ case OP_Transaction: { p->pTos = pTos; return SQLITE_BUSY; }else if( (*db->xBusyCallback)(db->pBusyArg, "", busy++)==0 ){ - sqlite3SetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0); + sqlite3SetString(&p->zErrMsg, sqlite3_error_string(rc), (char*)0); busy = 0; } break; @@ -2701,7 +2701,7 @@ case OP_OpenWrite: { p->pTos = &pTos[1 + (pOp->p2<=0)]; /* Operands must remain on stack */ return SQLITE_BUSY; }else if( (*db->xBusyCallback)(db->pBusyArg, pOp->p3, ++busy)==0 ){ - sqlite3SetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0); + sqlite3SetString(&p->zErrMsg, sqlite3_error_string(rc), (char*)0); busy = 0; } break; @@ -2855,7 +2855,7 @@ case OP_MoveTo: { pC->recnoIsValid = 0; } pC->deferredMoveto = 0; - sqlite_search_count++; + sqlite3_search_count++; oc = pOp->opcode; if( oc==OP_MoveTo && res<0 ){ sqlite3BtreeNext(pC->pCursor, &res); @@ -3187,7 +3187,7 @@ case OP_NewRecno: { ** incremented (otherwise not). If the OPFLAG_CSCHANGE flag is set, ** then the current statement change count is incremented (otherwise not). ** If the OPFLAG_LASTROWID flag of P2 is set, then rowid is -** stored for subsequent return by the sqlite_last_insert_rowid() function +** stored for subsequent return by the sqlite3_last_insert_rowid() function ** (otherwise it's unmodified). */ /* Opcode: PutStrKey P1 * * @@ -3694,7 +3694,7 @@ case OP_Next: { } if( res==0 ){ pc = pOp->p2 - 1; - sqlite_search_count++; + sqlite3_search_count++; } }else{ pC->nullRow = 1; @@ -4780,7 +4780,7 @@ case OP_AggFocus: { pc = pOp->p2 - 1; }else{ AggInsert(&p->agg, zKey, nKey); - if( sqlite_malloc_failed ) goto no_mem; + if( sqlite3_malloc_failed ) goto no_mem; } Release(pTos); pTos--; @@ -4913,7 +4913,7 @@ case OP_SetInsert: { Release(pTos); pTos--; } - if( sqlite_malloc_failed ) goto no_mem; + if( sqlite3_malloc_failed ) goto no_mem; break; } @@ -5013,7 +5013,7 @@ case OP_Vacuum: { /* An other opcode is illegal... */ default: { - sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode); + sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode); sqlite3SetString(&p->zErrMsg, "unknown opcode ", zBuf, (char*)0); rc = SQLITE_INTERNAL; break; @@ -5151,12 +5151,12 @@ abort_due_to_misuse: */ abort_due_to_error: if( p->zErrMsg==0 ){ - if( sqlite_malloc_failed ) rc = SQLITE_NOMEM; - sqlite3SetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0); + if( sqlite3_malloc_failed ) rc = SQLITE_NOMEM; + sqlite3SetString(&p->zErrMsg, sqlite3_error_string(rc), (char*)0); } goto vdbe_halt; - /* Jump to here if the sqlite_interrupt() API sets the interrupt + /* Jump to here if the sqlite3_interrupt() API sets the interrupt ** flag. */ abort_due_to_interrupt: @@ -5167,6 +5167,6 @@ abort_due_to_interrupt: }else{ rc = SQLITE_INTERRUPT; } - sqlite3SetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0); + sqlite3SetString(&p->zErrMsg, sqlite3_error_string(rc), (char*)0); goto vdbe_halt; } |