-C Add\ssome\sfunctions\sto\sserialize\sand\sdeserialize\svdbe\svalues\s(used\nby\smanifest\styping).\s(CVS\s1336)
-D 2004-05-10T10:05:54
+C Change\sthe\snames\sof\sexternal\ssymbols\sfrom\ssqlite_XXX\sto\ssqlite3_XXX.\s(CVS\s1337)
+D 2004-05-10T10:34:34
F Makefile.in ab7b0d5118e2da97bac66be8684a1034e3500f5a
F Makefile.linux-gcc b86a99c493a5bfb402d1d9178dcdc4bd4b32f906
F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd
F sqlite.def fc4f5734786fe4743cfe2aa98eb2da4b089edb5f
F sqlite.pc.in 30552343140c53304c2a658c080fbe810cd09ca2
F src/attach.c fa9a58234406d84eeb900517d0c0adc4b2da051a
-F src/auth.c a2a46e3ed7799134cf3d2dd5ae6650115f26b653
-F src/btree.c b4c04b7867ccabaa1b04d5691a1bc6d0a27e6c6b
+F src/auth.c 5c2f0bea4729c98c2be3b69d6b466fc51448fe79
+F src/btree.c b5950a1fece49f4a57f49a88b80610aae120bf16
F src/btree.h 7c3939a2e5f782c1ebac3bf43c02a16febad6df1
-F src/btree_rb.c 47e5b5ec90846af392b5668b34648198ba459561
-F src/build.c 44ee22de8168465ba99d780dbb2091b9c2822e56
-F src/copy.c 3c33157f6b4919d6851602b78008c67d466cdadd
-F src/date.c ca325e0752a88656ba798bc0666fa41498941732
-F src/delete.c c6f881904504619ef00c495d535aa0c60a1ddbdc
+F src/btree_rb.c 9d7973e266ee6f9c61ce592f68742ce9cd5b10e5
+F src/build.c 8d9965b3ce5dcc1bd4dac60bd0f14524fea269cb
+F src/copy.c 4d2038602fd0549d80c59bda27d96f13ea9b5e29
+F src/date.c 1564caa119511a1bb23dd0b1530ad38ed8c3349b
+F src/delete.c 889a7e9f0365622a2ad5859d9c9df10ece12e363
F src/encode.c a876af473d1d636faa3dca51c7571f2e007eea37
-F src/expr.c efd9daf50407ed27a0a50753e6d6c086320260cd
-F src/func.c f87eec5cf103f739ba32866660ce22d000c5723f
+F src/expr.c 7667e214b17a100e013005d42c1b91be73d9ecfe
+F src/func.c 6cf6501f092b41c8cd9368b09c287016c0576438
F src/hash.c 440c2f8cb373ee1b4e13a0988489c7cd95d55b6f
F src/hash.h 762d95f1e567664d1eafc1687de755626be962fb
-F src/insert.c 954c0ddabc10899526c975b403ca4352d253f2e0
-F src/main.c f60224784f2f3d862ad116777cfe6596dbaaeb16
+F src/insert.c 2d082257784a8613b1b50cd5bbf42b9466646a0e
+F src/main.c 45f0dc84265d18b0e99500dced4975df8a041481
F src/md5.c 01d2f55b06316d242749759b6a37186439ef7fe3
F src/os.c 4092dcc87e66f49ed660fae1519569a0cee34da0
F src/os.h fbb2f6595fc34fa351830d88fe1c6b85118f0383
F www/tclsqlite.tcl b9271d44dcf147a93c98f8ecf28c927307abd6da
F www/vdbe.tcl 9b9095d4495f37697fd1935d10e14c6015e80aa1
F www/whentouse.tcl a8335bce47cc2fddb07f19052cb0cb4d9129a8e4
-P 9ea8e8ab23d46adb2970ccf62340703ec42345fa
-R 618584a23469029fa2139630ad76562b
+P 05434497ba5d9971d23144eb4b9d709c233f6546
+R 61565b7b4d0b0c747dc3c710b9222d1e
U danielk1977
-Z 0608f60d741fd851f2193190bf722d0f
+Z cdb3555cc5ea64d3d31c0c0c46963b23
-05434497ba5d9971d23144eb4b9d709c233f6546
\ No newline at end of file
+ba2ba24263a9e4d1b65b441295504a5da6380f33
\ No newline at end of file
** May you share freely, never taking more than you give.
**
*************************************************************************
-** This file contains code used to implement the sqlite_set_authorizer()
+** This file contains code used to implement the sqlite3_set_authorizer()
** API. This facility is an optional feature of the library. Embedded
** systems that do not need this facility may omit it by recompiling
** the library with -DSQLITE_OMIT_AUTHORIZATION=1
**
-** $Id: auth.c,v 1.13 2004/05/08 08:23:21 danielk1977 Exp $
+** $Id: auth.c,v 1.14 2004/05/10 10:34:34 danielk1977 Exp $
*/
#include "sqliteInt.h"
** the table and the column that are being accessed. The auth function
** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If
** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY
-** means that the SQL statement will never-run - the sqlite_exec() call
+** means that the SQL statement will never-run - the sqlite3_exec() call
** will return with an error. SQLITE_IGNORE means that the SQL statement
** should run but attempts to read the specified column will return NULL
** and attempts to write the column will be ignored.
** Setting the auth function to NULL disables this hook. The default
** setting of the auth function is NULL.
*/
-int sqlite_set_authorizer(
+int sqlite3_set_authorizer(
sqlite *db,
int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
void *pArg
** May you share freely, never taking more than you give.
**
*************************************************************************
-** $Id: btree.c,v 1.120 2004/05/09 20:40:11 drh Exp $
+** $Id: btree.c,v 1.121 2004/05/10 10:34:34 danielk1977 Exp $
**
** This file implements a external (disk-based) database using BTrees.
** For a detailed discussion of BTrees, refer to
static int resizeCellArray(MemPage *pPage, int nNewSz){
if( pPage->nCellAlloc<nNewSz ){
pPage->aCell = sqliteRealloc(pPage->aCell, nNewSz*sizeof(pPage->aCell[0]) );
- if( sqlite_malloc_failed ) return SQLITE_NOMEM;
+ if( sqlite3_malloc_failed ) return SQLITE_NOMEM;
pPage->nCellAlloc = nNewSz;
}
return SQLITE_OK;
** May you share freely, never taking more than you give.
**
*************************************************************************
-** $Id: btree_rb.c,v 1.25 2004/05/08 08:23:23 danielk1977 Exp $
+** $Id: btree_rb.c,v 1.26 2004/05/10 10:34:35 danielk1977 Exp $
**
** This file implements an in-core database using Red-Black balanced
** binary trees.
){
Rbtree **ppRbtree = (Rbtree**)ppBtree;
*ppRbtree = (Rbtree *)sqliteMalloc(sizeof(Rbtree));
- if( sqlite_malloc_failed ) goto open_no_mem;
+ if( sqlite3_malloc_failed ) goto open_no_mem;
sqlite3HashInit(&(*ppRbtree)->tblHash, SQLITE_HASH_INT, 0);
/* Create a binary tree for the SQLITE_MASTER table at location 2 */
btreeCreateTable(*ppRbtree, 2);
- if( sqlite_malloc_failed ) goto open_no_mem;
+ if( sqlite3_malloc_failed ) goto open_no_mem;
(*ppRbtree)->next_idx = 3;
(*ppRbtree)->pOps = &sqliteRbtreeOps;
/* Set file type to 4; this is so that "attach ':memory:' as ...." does not
*n = tree->next_idx++;
btreeCreateTable(tree, *n);
- if( sqlite_malloc_failed ) return SQLITE_NOMEM;
+ if( sqlite3_malloc_failed ) return SQLITE_NOMEM;
/* Set up the rollback structure (if we are not doing this as part of a
* rollback) */
RbtCursor *pCur;
assert(tree);
pCur = *ppCur = sqliteMalloc(sizeof(RbtCursor));
- if( sqlite_malloc_failed ) return SQLITE_NOMEM;
+ if( sqlite3_malloc_failed ) return SQLITE_NOMEM;
pCur->pTree = sqlite3HashFind(&tree->tblHash, 0, iTable);
assert( pCur->pTree );
pCur->pRbtree = tree;
/* Take a copy of the input data now, in case we need it for the
* replace case */
pData = sqliteMallocRaw(nData);
- if( sqlite_malloc_failed ) return SQLITE_NOMEM;
+ if( sqlite3_malloc_failed ) return SQLITE_NOMEM;
memcpy(pData, pDataInput, nData);
/* Move the cursor to a node near the key to be inserted. If the key already
if( pNode==0 ) return SQLITE_NOMEM;
pNode->nKey = nKey;
pNode->pKey = sqliteMallocRaw(nKey);
- if( sqlite_malloc_failed ) return SQLITE_NOMEM;
+ if( sqlite3_malloc_failed ) return SQLITE_NOMEM;
memcpy(pNode->pKey, pKey, nKey);
pNode->nData = nData;
pNode->pData = pData;
pOp->iTab = pCur->iTree;
pOp->nKey = pNode->nKey;
pOp->pKey = sqliteMallocRaw( pOp->nKey );
- if( sqlite_malloc_failed ) return SQLITE_NOMEM;
+ if( sqlite3_malloc_failed ) return SQLITE_NOMEM;
memcpy( pOp->pKey, pNode->pKey, pOp->nKey );
btreeLogRollbackOp(pCur->pRbtree, pOp);
}
pOp->iTab = pCur->iTree;
pOp->nKey = pCur->pNode->nKey;
pOp->pKey = sqliteMallocRaw( pOp->nKey );
- if( sqlite_malloc_failed ) return SQLITE_NOMEM;
+ if( sqlite3_malloc_failed ) return SQLITE_NOMEM;
memcpy( pOp->pKey, pCur->pNode->pKey, pOp->nKey );
pOp->nData = pCur->pNode->nData;
pOp->pData = pCur->pNode->pData;
** ROLLBACK
** PRAGMA
**
-** $Id: build.c,v 1.178 2004/05/10 01:17:37 danielk1977 Exp $
+** $Id: build.c,v 1.179 2004/05/10 10:34:35 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
if( v==0 && (v = sqlite3GetVdbe(pParse))!=0 ){
sqlite3VdbeAddOp(v, OP_Halt, 0, 0);
}
- if( sqlite_malloc_failed ) return;
+ if( sqlite3_malloc_failed ) return;
if( v && pParse->nErr==0 ){
FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;
sqlite3VdbeTrace(v, trace);
Table *p;
sqlite *db = pParse->db;
- if( (pEnd==0 && pSelect==0) || pParse->nErr || sqlite_malloc_failed ) return;
+ if( (pEnd==0 && pSelect==0) || pParse->nErr || sqlite3_malloc_failed ) return;
p = pParse->pNewTable;
if( p==0 ) return;
/* Make a copy of the entire SELECT statement that defines the view.
** This will force all the Expr.token.z values to be dynamically
** allocated rather than point to the input string - which means that
- ** they will persist after the current sqlite_exec() call returns.
+ ** they will persist after the current sqlite3_exec() call returns.
*/
p->pSelect = sqlite3SelectDup(pSelect);
sqlite3SelectDelete(pSelect);
sqlite *db = pParse->db;
int iDb;
- if( pParse->nErr || sqlite_malloc_failed ) return;
+ if( pParse->nErr || sqlite3_malloc_failed ) return;
pTable = sqlite3TableFromToken(pParse, pName);
if( pTable==0 ) return;
iDb = pTable->iDb;
int isTemp; /* True for a temporary index */
sqlite *db = pParse->db;
- if( pParse->nErr || sqlite_malloc_failed ) goto exit_create_index;
+ if( pParse->nErr || sqlite3_malloc_failed ) goto exit_create_index;
if( db->init.busy
&& sqlite3FixInit(&sFix, pParse, db->init.iDb, "index", pName)
&& sqlite3FixSrcList(&sFix, pTable)
Vdbe *v;
sqlite *db = pParse->db;
- if( pParse->nErr || sqlite_malloc_failed ) return;
+ if( pParse->nErr || sqlite3_malloc_failed ) return;
assert( pName->nSrc==1 );
pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
if( pIndex==0 ){
sqlite *db;
if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
- if( pParse->nErr || sqlite_malloc_failed ) return;
+ if( pParse->nErr || sqlite3_malloc_failed ) return;
if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ) return;
if( db->flags & SQLITE_InTrans ){
sqlite3ErrorMsg(pParse, "cannot start a transaction within a transaction");
sqlite *db;
if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
- if( pParse->nErr || sqlite_malloc_failed ) return;
+ if( pParse->nErr || sqlite3_malloc_failed ) return;
if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ) return;
if( (db->flags & SQLITE_InTrans)==0 ){
sqlite3ErrorMsg(pParse, "cannot commit - no transaction is active");
Vdbe *v;
if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return;
- if( pParse->nErr || sqlite_malloc_failed ) return;
+ if( pParse->nErr || sqlite3_malloc_failed ) return;
if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ) return;
if( (db->flags & SQLITE_InTrans)==0 ){
sqlite3ErrorMsg(pParse, "cannot rollback - no transaction is active");
*************************************************************************
** This file contains code used to implement the COPY command.
**
-** $Id: copy.c,v 1.10 2004/05/08 08:23:24 danielk1977 Exp $
+** $Id: copy.c,v 1.11 2004/05/10 10:34:35 danielk1977 Exp $
*/
#include "sqliteInt.h"
sqlite *db = pParse->db;
- if( sqlite_malloc_failed ) goto copy_cleanup;
+ if( sqlite3_malloc_failed ) goto copy_cleanup;
assert( pTableName->nSrc==1 );
pTab = sqlite3SrcListLookup(pParse, pTableName);
if( pTab==0 || sqlite3IsReadOnly(pParse, pTab, 0) ) goto copy_cleanup;
** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
** All other code has file scope.
**
-** $Id: date.c,v 1.17 2004/05/08 08:23:24 danielk1977 Exp $
+** $Id: date.c,v 1.18 2004/05/10 10:34:35 danielk1977 Exp $
**
** NOTES:
**
DateTime x;
if( isDate(argc, argv, &x)==0 ){
computeJD(&x);
- sqlite_set_result_double(context, x.rJD);
+ sqlite3_set_result_double(context, x.rJD);
}
}
computeYMD_HMS(&x);
sprintf(zBuf, "%04d-%02d-%02d %02d:%02d:%02d",x.Y, x.M, x.D, x.h, x.m,
(int)(x.s));
- sqlite_set_result_string(context, zBuf, -1);
+ sqlite3_set_result_string(context, zBuf, -1);
}
}
char zBuf[100];
computeHMS(&x);
sprintf(zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
- sqlite_set_result_string(context, zBuf, -1);
+ sqlite3_set_result_string(context, zBuf, -1);
}
}
char zBuf[100];
computeYMD(&x);
sprintf(zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
- sqlite_set_result_string(context, zBuf, -1);
+ sqlite3_set_result_string(context, zBuf, -1);
}
}
}
}
z[j] = 0;
- sqlite_set_result_string(context, z, -1);
+ sqlite3_set_result_string(context, z, -1);
if( z!=zBuf ){
sqliteFree(z);
}
int i;
for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
- sqlite_create_function(db, aFuncs[i].zName,
+ sqlite3_create_function(db, aFuncs[i].zName,
aFuncs[i].nArg, aFuncs[i].xFunc, 0);
if( aFuncs[i].xFunc ){
- sqlite_function_type(db, aFuncs[i].zName, aFuncs[i].dataType);
+ sqlite3_function_type(db, aFuncs[i].zName, aFuncs[i].dataType);
}
}
}
** This file contains C code routines that are called by the parser
** to handle DELETE FROM statements.
**
-** $Id: delete.c,v 1.62 2004/05/08 08:23:24 danielk1977 Exp $
+** $Id: delete.c,v 1.63 2004/05/10 10:34:35 danielk1977 Exp $
*/
#include "sqliteInt.h"
int oldIdx = -1; /* Cursor for the OLD table of AFTER triggers */
sContext.pParse = 0;
- if( pParse->nErr || sqlite_malloc_failed ){
+ if( pParse->nErr || sqlite3_malloc_failed ){
pTabList = 0;
goto delete_from_cleanup;
}
** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite.
**
-** $Id: expr.c,v 1.115 2004/05/08 08:23:24 danielk1977 Exp $
+** $Id: expr.c,v 1.116 2004/05/10 10:34:37 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
sqlite3TokenCopy(&pNewExpr->span, &pOldExpr->span);
}
assert( pNewExpr==0 || pNewExpr->span.z!=0
- || pOldExpr->span.z==0 || sqlite_malloc_failed );
+ || pOldExpr->span.z==0 || sqlite3_malloc_failed );
pItem->zName = sqliteStrDup(p->a[i].zName);
pItem->sortOrder = p->a[i].sortOrder;
pItem->isAgg = p->a[i].isAgg;
}
zCol = sqliteStrNDup(pColumnToken->z, pColumnToken->n);
sqlite3Dequote(zCol);
- if( sqlite_malloc_failed ){
+ if( sqlite3_malloc_failed ){
return 1; /* Leak memory (zDb and zTab) if malloc fails */
}
assert( zTab==0 || pEList==0 );
** sqliteRegisterBuildinFunctions() found at the bottom of the file.
** All other code has file scope.
**
-** $Id: func.c,v 1.44 2004/05/08 08:23:25 danielk1977 Exp $
+** $Id: func.c,v 1.45 2004/05/10 10:34:38 danielk1977 Exp $
*/
#include <ctype.h>
#include <math.h>
int mask; /* 0 for min() or 0xffffffff for max() */
if( argc==0 ) return;
- mask = (int)sqlite_user_data(context);
+ mask = (int)sqlite3_user_data(context);
zBest = argv[0];
if( zBest==0 ) return;
if( argv[1][0]=='n' ){
zBest = argv[i];
}
}
- sqlite_set_result_string(context, zBest, -1);
+ sqlite3_set_result_string(context, zBest, -1);
}
/*
*/
static void typeofFunc(sqlite_func *context, int argc, const char **argv){
assert( argc==2 );
- sqlite_set_result_string(context, argv[1], -1);
+ sqlite3_set_result_string(context, argv[1], -1);
}
/*
#else
len = strlen(z);
#endif
- sqlite_set_result_int(context, len);
+ sqlite3_set_result_int(context, len);
}
/*
z = argv[0];
if( z==0 ) return;
if( z[0]=='-' && isdigit(z[1]) ) z++;
- sqlite_set_result_string(context, z, -1);
+ sqlite3_set_result_string(context, z, -1);
}
/*
while( z[i] && (z[i]&0xc0)==0x80 ){ i++; p2++; }
#endif
if( p2<0 ) p2 = 0;
- sqlite_set_result_string(context, &z[p1], p2);
+ sqlite3_set_result_string(context, &z[p1], p2);
}
/*
if( n<0 ) n = 0;
r = sqlite3AtoF(argv[0], 0);
sprintf(zBuf,"%.*f",n,r);
- sqlite_set_result_string(context, zBuf, -1);
+ sqlite3_set_result_string(context, zBuf, -1);
}
/*
char *z;
int i;
if( argc<1 || argv[0]==0 ) return;
- z = sqlite_set_result_string(context, argv[0], -1);
+ z = sqlite3_set_result_string(context, argv[0], -1);
if( z==0 ) return;
for(i=0; z[i]; i++){
if( islower(z[i]) ) z[i] = toupper(z[i]);
char *z;
int i;
if( argc<1 || argv[0]==0 ) return;
- z = sqlite_set_result_string(context, argv[0], -1);
+ z = sqlite3_set_result_string(context, argv[0], -1);
if( z==0 ) return;
for(i=0; z[i]; i++){
if( isupper(z[i]) ) z[i] = tolower(z[i]);
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;
}
}
static void randomFunc(sqlite_func *context, int argc, const char **argv){
int r;
sqlite3Randomness(sizeof(r), &r);
- sqlite_set_result_int(context, r);
+ sqlite3_set_result_int(context, r);
}
/*
** Implementation of the last_insert_rowid() SQL function. The return
-** value is the same as the sqlite_last_insert_rowid() API function.
+** value is the same as the sqlite3_last_insert_rowid() API function.
*/
static void last_insert_rowid(sqlite_func *context, int arg, const char **argv){
- sqlite *db = sqlite_user_data(context);
- sqlite_set_result_int(context, sqlite_last_insert_rowid(db));
+ sqlite *db = sqlite3_user_data(context);
+ sqlite3_set_result_int(context, sqlite3_last_insert_rowid(db));
}
/*
** Implementation of the change_count() SQL function. The return
-** value is the same as the sqlite_changes() API function.
+** value is the same as the sqlite3_changes() API function.
*/
static void change_count(sqlite_func *context, int arg, const char **argv){
- sqlite *db = sqlite_user_data(context);
- sqlite_set_result_int(context, sqlite_changes(db));
+ sqlite *db = sqlite3_user_data(context);
+ sqlite3_set_result_int(context, sqlite3_changes(db));
}
/*
** Implementation of the last_statement_change_count() SQL function. The
-** return value is the same as the sqlite_last_statement_changes() API function.
+** return value is the same as the sqlite3_last_statement_changes() API function.
*/
static void last_statement_change_count(sqlite_func *context, int arg,
const char **argv){
- sqlite *db = sqlite_user_data(context);
- sqlite_set_result_int(context, sqlite_last_statement_changes(db));
+ sqlite *db = sqlite3_user_data(context);
+ sqlite3_set_result_int(context, sqlite3_last_statement_changes(db));
}
/*
*/
static void likeFunc(sqlite_func *context, int arg, const char **argv){
if( argv[0]==0 || argv[1]==0 ) return;
- sqlite_set_result_int(context,
+ sqlite3_set_result_int(context,
sqlite3LikeCompare((const unsigned char*)argv[0],
(const unsigned char*)argv[1]));
}
*/
static void globFunc(sqlite_func *context, int arg, const char **argv){
if( argv[0]==0 || argv[1]==0 ) return;
- sqlite_set_result_int(context,
+ sqlite3_set_result_int(context,
sqlite3GlobCompare((const unsigned char*)argv[0],
(const unsigned char*)argv[1]));
}
*/
static void nullifFunc(sqlite_func *context, int argc, const char **argv){
if( argv[0]!=0 && sqlite3Compare(argv[0],argv[1])!=0 ){
- sqlite_set_result_string(context, argv[0], -1);
+ sqlite3_set_result_string(context, argv[0], -1);
}
}
** of the SQLite library that is running.
*/
static void versionFunc(sqlite_func *context, int argc, const char **argv){
- sqlite_set_result_string(context, sqlite_version, -1);
+ sqlite3_set_result_string(context, sqlite3_version, -1);
}
/*
static void quoteFunc(sqlite_func *context, int argc, const char **argv){
if( argc<1 ) return;
if( argv[0]==0 ){
- sqlite_set_result_string(context, "NULL", 4);
+ sqlite3_set_result_string(context, "NULL", 4);
}else if( sqlite3IsNumber(argv[0]) ){
- sqlite_set_result_string(context, argv[0], -1);
+ sqlite3_set_result_string(context, argv[0], -1);
}else{
int i,j,n;
char *z;
}
z[j++] = '\'';
z[j] = 0;
- sqlite_set_result_string(context, z, j);
+ sqlite3_set_result_string(context, z, j);
sqliteFree(z);
}
}
zResult[j++] = '0';
}
zResult[j] = 0;
- sqlite_set_result_string(context, zResult, 4);
+ sqlite3_set_result_string(context, zResult, 4);
}else{
- sqlite_set_result_string(context, "?000", 4);
+ sqlite3_set_result_string(context, "?000", 4);
}
}
#endif
zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
}
zBuf[n] = 0;
- sqlite_set_result_string(context, zBuf, n);
+ sqlite3_set_result_string(context, zBuf, n);
}
#endif
static void sumStep(sqlite_func *context, int argc, const char **argv){
SumCtx *p;
if( argc<1 ) return;
- p = sqlite_aggregate_context(context, sizeof(*p));
+ p = sqlite3_aggregate_context(context, sizeof(*p));
if( p && argv[0] ){
p->sum += sqlite3AtoF(argv[0], 0);
p->cnt++;
}
static void sumFinalize(sqlite_func *context){
SumCtx *p;
- p = sqlite_aggregate_context(context, sizeof(*p));
- sqlite_set_result_double(context, p ? p->sum : 0.0);
+ p = sqlite3_aggregate_context(context, sizeof(*p));
+ sqlite3_set_result_double(context, p ? p->sum : 0.0);
}
static void avgFinalize(sqlite_func *context){
SumCtx *p;
- p = sqlite_aggregate_context(context, sizeof(*p));
+ p = sqlite3_aggregate_context(context, sizeof(*p));
if( p && p->cnt>0 ){
- sqlite_set_result_double(context, p->sum/(double)p->cnt);
+ sqlite3_set_result_double(context, p->sum/(double)p->cnt);
}
}
StdDevCtx *p;
double x;
if( argc<1 ) return;
- p = sqlite_aggregate_context(context, sizeof(*p));
+ p = sqlite3_aggregate_context(context, sizeof(*p));
if( p && argv[0] ){
x = sqlite3AtoF(argv[0], 0);
p->sum += x;
}
}
static void stdDevFinalize(sqlite_func *context){
- double rN = sqlite_aggregate_count(context);
- StdDevCtx *p = sqlite_aggregate_context(context, sizeof(*p));
+ double rN = sqlite3_aggregate_count(context);
+ StdDevCtx *p = sqlite3_aggregate_context(context, sizeof(*p));
if( p && p->cnt>1 ){
double rCnt = cnt;
- sqlite_set_result_double(context,
+ sqlite3_set_result_double(context,
sqrt((p->sum2 - p->sum*p->sum/rCnt)/(rCnt-1.0)));
}
}
*/
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);
}
/*
}else{
xCompare = strcmp;
}
- mask = (int)sqlite_user_data(context);
- p = sqlite_aggregate_context(context, sizeof(*p));
+ mask = (int)sqlite3_user_data(context);
+ p = sqlite3_aggregate_context(context, sizeof(*p));
if( p==0 || argc<1 || argv[0]==0 ) return;
if( p->z==0 || (xCompare(argv[0],p->z)^mask)<0 ){
int len;
}
static void minMaxFinalize(sqlite_func *context){
MinMaxCtx *p;
- p = sqlite_aggregate_context(context, sizeof(*p));
+ p = sqlite3_aggregate_context(context, sizeof(*p));
if( p && p->z ){
- sqlite_set_result_string(context, p->z, strlen(p->z));
+ sqlite3_set_result_string(context, p->z, strlen(p->z));
}
if( p && !p->zBuf[0] ){
sqliteFree(p->z);
{ "like", 2, SQLITE_NUMERIC, 0, likeFunc },
{ "glob", 2, SQLITE_NUMERIC, 0, globFunc },
{ "nullif", 2, SQLITE_ARGS, 0, nullifFunc },
- { "sqlite_version",0,SQLITE_TEXT, 0, versionFunc},
+ { "sqlite3_version",0,SQLITE_TEXT, 0, versionFunc},
{ "quote", 1, SQLITE_ARGS, 0, quoteFunc },
{ "last_insert_rowid", 0, SQLITE_NUMERIC, 1, last_insert_rowid },
{ "change_count", 0, SQLITE_NUMERIC, 1, change_count },
for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
void *pArg = aFuncs[i].argType==2 ? (void*)(-1) : db;
- sqlite_create_function(db, aFuncs[i].zName,
+ sqlite3_create_function(db, aFuncs[i].zName,
aFuncs[i].nArg, aFuncs[i].xFunc, pArg);
if( aFuncs[i].xFunc ){
- sqlite_function_type(db, aFuncs[i].zName, aFuncs[i].dataType);
+ sqlite3_function_type(db, aFuncs[i].zName, aFuncs[i].dataType);
}
}
for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){
void *pArg = aAggs[i].argType==2 ? (void*)(-1) : db;
- sqlite_create_aggregate(db, aAggs[i].zName,
+ sqlite3_create_aggregate(db, aAggs[i].zName,
aAggs[i].nArg, aAggs[i].xStep, aAggs[i].xFinalize, pArg);
- sqlite_function_type(db, aAggs[i].zName, aAggs[i].dataType);
+ sqlite3_function_type(db, aAggs[i].zName, aAggs[i].dataType);
}
for(i=0; i<sizeof(azTypeFuncs)/sizeof(azTypeFuncs[0]); i++){
int n = strlen(azTypeFuncs[i]);
** This file contains C code routines that are called by the parser
** to handle INSERT statements in SQLite.
**
-** $Id: insert.c,v 1.95 2004/05/08 08:23:25 danielk1977 Exp $
+** $Id: insert.c,v 1.96 2004/05/10 10:34:40 danielk1977 Exp $
*/
#include "sqliteInt.h"
int after_triggers; /* True if there are AFTER triggers */
int newIdx = -1; /* Cursor for the NEW table */
- if( pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup;
+ if( pParse->nErr || sqlite3_malloc_failed ) goto insert_cleanup;
db = pParse->db;
/* Locate the table into which we will be inserting new information.
iSelectLoop = sqlite3VdbeCurrentAddr(v);
iInsertBlock = sqlite3VdbeMakeLabel(v);
rc = sqlite3Select(pParse, pSelect, SRT_Subroutine, iInsertBlock, 0,0,0);
- if( rc || pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup;
+ if( rc || pParse->nErr || sqlite3_malloc_failed ) goto insert_cleanup;
iCleanup = sqlite3VdbeMakeLabel(v);
sqlite3VdbeAddOp(v, OP_Goto, 0, iCleanup);
assert( pSelect->pEList );
** Constraint type Action What Happens
** --------------- ---------- ----------------------------------------
** any ROLLBACK The current transaction is rolled back and
-** sqlite_exec() returns immediately with a
+** sqlite3_exec() returns immediately with a
** return code of SQLITE_CONSTRAINT.
**
** any ABORT Back out changes from the current command
** only (do not do a complete rollback) then
-** cause sqlite_exec() to return immediately
+** cause sqlite3_exec() to return immediately
** with SQLITE_CONSTRAINT.
**
** any FAIL Sqlite_exec() returns immediately with a
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
-** $Id: main.c,v 1.167 2004/05/10 01:17:37 danielk1977 Exp $
+** $Id: main.c,v 1.168 2004/05/10 10:34:43 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
db->init.iDb = atoi(argv[4]);
assert( db->init.iDb>=0 && db->init.iDb<db->nDb );
db->init.newTnum = atoi(argv[2]);
- if( sqlite_exec(db, argv[3], 0, 0, &zErr) ){
+ if( sqlite3_exec(db, argv[3], 0, 0, &zErr) ){
corruptSchema(pData, zErr);
- sqlite_freemem(zErr);
+ sqlite3_freemem(zErr);
}
db->init.iDb = 0;
}else{
pTrig = pTab->pTrigger;
pTab->pTrigger = 0; /* Disable all triggers before rebuilding the table */
}
- rc = sqlite_exec_printf(pData->db,
+ rc = sqlite3_exec_printf(pData->db,
"CREATE TEMP TABLE sqlite_x AS SELECT * FROM '%q'; "
"DELETE FROM '%q'; "
"INSERT INTO '%q' SELECT * FROM sqlite_x; "
"DROP TABLE sqlite_x;",
0, 0, &zErr, argv[0], argv[0], argv[0]);
if( zErr ){
- if( *pData->pzErrMsg ) sqlite_freemem(*pData->pzErrMsg);
+ if( *pData->pzErrMsg ) sqlite3_freemem(*pData->pzErrMsg);
*pData->pzErrMsg = zErr;
}
if( db->aDb[iDb].pBt==0 ) return SQLITE_OK;
rc = sqlite3BtreeCursor(db->aDb[iDb].pBt, MASTER_ROOT, 0, 0, 0, &curMain);
if( rc ){
- sqlite3SetString(pzErrMsg, sqlite_error_string(rc), (char*)0);
+ sqlite3SetString(pzErrMsg, sqlite3_error_string(rc), (char*)0);
return rc;
}
}
}
if( rc ){
- sqlite3SetString(pzErrMsg, sqlite_error_string(rc), (char*)0);
+ sqlite3SetString(pzErrMsg, sqlite3_error_string(rc), (char*)0);
sqlite3BtreeCloseCursor(curMain);
return rc;
}
assert( db->init.busy );
sqlite3SafetyOff(db);
if( iDb==0 ){
- rc = sqlite_exec(db,
+ rc = sqlite3_exec(db,
db->file_format>=2 ? init_script : older_init_script,
sqlite3InitCallback, &initData, 0);
}else{
sqlite3SetString(&zSql,
"SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"",
db->aDb[iDb].zName, "\".sqlite_master", (char*)0);
- rc = sqlite_exec(db, zSql, sqlite3InitCallback, &initData, 0);
+ rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
sqliteFree(zSql);
}
sqlite3SafetyOn(db);
sqlite3BtreeCloseCursor(curMain);
- if( sqlite_malloc_failed ){
+ if( sqlite3_malloc_failed ){
sqlite3SetString(pzErrMsg, "out of memory", (char*)0);
rc = SQLITE_NOMEM;
sqlite3ResetInternalSchema(db, 0);
initData.db = db;
initData.pzErrMsg = &zErr;
db->file_format = 3;
- rc = sqlite_exec(db,
+ rc = sqlite3_exec(db,
"BEGIN; SELECT name FROM sqlite_master WHERE type='table';",
upgrade_3_callback,
&initData,
for(ii=0; rc==SQLITE_OK && ii<SQLITE_N_BTREE_META; ii++){
rc = sqlite3BtreeUpdateMeta(db->aDb[0].pBt, ii+1, meta[ii]);
}
- sqlite_exec(db, "COMMIT", 0, 0, 0);
+ sqlite3_exec(db, "COMMIT", 0, 0, 0);
}
if( rc!=SQLITE_OK ){
sqlite3SetString(pzErrMsg,
"unable to upgrade database to the version 2.6 format",
zErr ? ": " : 0, zErr, (char*)0);
}
- sqlite_freemem(zErr);
+ sqlite3_freemem(zErr);
}
if( rc!=SQLITE_OK ){
** The version of the library
*/
const char rcsid[] = "@(#) \044Id: SQLite version " SQLITE_VERSION " $";
-const char sqlite_version[] = SQLITE_VERSION;
+const char sqlite3_version[] = SQLITE_VERSION;
/*
** Does the library expect data to be encoded as UTF-8 or iso8859? The
** following global constant always lets us know.
*/
#ifdef SQLITE_UTF8
-const char sqlite_encoding[] = "UTF-8";
+const char sqlite3_encoding[] = "UTF-8";
#else
-const char sqlite_encoding[] = "iso8859";
+const char sqlite3_encoding[] = "iso8859";
#endif
/*
** An attempt is made to initialize the in-memory data structures that
** hold the database schema. But if this fails (because the schema file
** is locked) then that step is deferred until the first call to
-** sqlite_exec().
+** sqlite3_exec().
*/
-sqlite *sqlite_open(const char *zFilename, int mode, char **pzErrMsg){
+sqlite *sqlite3_open(const char *zFilename, int mode, char **pzErrMsg){
sqlite *db;
int rc, i;
sqlite3RegisterBuiltinFunctions(db);
rc = sqlite3Init(db, pzErrMsg);
db->magic = SQLITE_MAGIC_OPEN;
- if( sqlite_malloc_failed ){
- sqlite_close(db);
+ if( sqlite3_malloc_failed ){
+ sqlite3_close(db);
goto no_mem_on_open;
}else if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
- sqlite_close(db);
+ sqlite3_close(db);
sqlite3StrRealloc(pzErrMsg);
return 0;
}else if( pzErrMsg ){
/*
** Return the ROWID of the most recent insert
*/
-int sqlite_last_insert_rowid(sqlite *db){
+int sqlite3_last_insert_rowid(sqlite *db){
return db->lastRowid;
}
/*
-** Return the number of changes in the most recent call to sqlite_exec().
+** Return the number of changes in the most recent call to sqlite3_exec().
*/
-int sqlite_changes(sqlite *db){
+int sqlite3_changes(sqlite *db){
return db->nChange;
}
** changes due to SQL statements executed in trigger programs that were
** triggered by that statement
*/
-int sqlite_last_statement_changes(sqlite *db){
+int sqlite3_last_statement_changes(sqlite *db){
return db->lsChange;
}
/*
** Close an existing SQLite database
*/
-void sqlite_close(sqlite *db){
+void sqlite3_close(sqlite *db){
HashElem *i;
int j;
db->want_to_close = 1;
** argument to xCallback(). If xCallback=NULL then no callback
** is invoked, even for queries.
*/
-int sqlite_exec(
+int sqlite3_exec(
sqlite *db, /* The database on which the SQL executes */
const char *zSql, /* The SQL to be executed */
sqlite_callback xCallback, /* Invoke this callback routine */
if( zSql==0 ) return SQLITE_OK;
while( rc==SQLITE_OK && zSql[0] ){
pVm = 0;
- rc = sqlite_compile(db, zSql, &zLeftover, &pVm, pzErrMsg);
+ rc = sqlite3_compile(db, zSql, &zLeftover, &pVm, pzErrMsg);
if( rc!=SQLITE_OK ){
- assert( pVm==0 || sqlite_malloc_failed );
+ assert( pVm==0 || sqlite3_malloc_failed );
return rc;
}
if( pVm==0 ){
while(1){
int nArg;
char **azArg, **azCol;
- rc = sqlite_step(pVm, &nArg, (const char***)&azArg,(const char***)&azCol);
+ rc = sqlite3_step(pVm, &nArg, (const char***)&azArg,(const char***)&azCol);
if( rc==SQLITE_ROW ){
if( xCallback!=0 && xCallback(pArg, nArg, azArg, azCol) ){
- sqlite_finalize(pVm, 0);
+ sqlite3_finalize(pVm, 0);
return SQLITE_ABORT;
}
nCallback++;
&& (db->flags & SQLITE_NullCallback)!=0 && xCallback!=0 ){
xCallback(pArg, nArg, azArg, azCol);
}
- rc = sqlite_finalize(pVm, pzErrMsg);
+ rc = sqlite3_finalize(pVm, pzErrMsg);
if( rc==SQLITE_SCHEMA && nRetry<2 ){
nRetry++;
rc = SQLITE_OK;
** of the SQLITE_ success/failure codes. Also write an error message into
** memory obtained from malloc() and make *pzErrMsg point to that message.
*/
-int sqlite_compile(
+int sqlite3_compile(
sqlite *db, /* The database on which the SQL executes */
const char *zSql, /* The SQL to be executed */
const char **pzTail, /* OUT: Next statement after the first */
}else{
/* If a memory error occurred during the copy,
** trace entire SQL string and fall through to the
- ** sqlite_malloc_failed test to report the error.
+ ** sqlite3_malloc_failed test to report the error.
*/
db->xTrace(db->pTraceArg, zSql);
}
db->xTrace(db->pTraceArg, zSql);
}
}
- if( sqlite_malloc_failed ){
+ if( sqlite3_malloc_failed ){
sqlite3SetString(pzErrMsg, "out of memory", (char*)0);
sParse.rc = SQLITE_NOMEM;
sqlite3RollbackAll(db);
}
if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;
if( sParse.rc!=SQLITE_OK && pzErrMsg && *pzErrMsg==0 ){
- sqlite3SetString(pzErrMsg, sqlite_error_string(sParse.rc), (char*)0);
+ sqlite3SetString(pzErrMsg, sqlite3_error_string(sParse.rc), (char*)0);
}
sqlite3StrRealloc(pzErrMsg);
if( sParse.rc==SQLITE_SCHEMA ){
exec_misuse:
if( pzErrMsg ){
*pzErrMsg = 0;
- sqlite3SetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0);
+ sqlite3SetString(pzErrMsg, sqlite3_error_string(SQLITE_MISUSE), (char*)0);
sqlite3StrRealloc(pzErrMsg);
}
return SQLITE_MISUSE;
/*
** The following routine destroys a virtual machine that is created by
-** the sqlite_compile() routine.
+** the sqlite3_compile() routine.
**
** The integer returned is an SQLITE_ success/failure code that describes
** the result of executing the virtual machine. An error message is
** written into memory obtained from malloc and *pzErrMsg is made to
** point to that error if pzErrMsg is not NULL. The calling routine
-** should use sqlite_freemem() to delete the message when it has finished
+** should use sqlite3_freemem() to delete the message when it has finished
** with it.
*/
-int sqlite_finalize(
+int sqlite3_finalize(
sqlite_vm *pVm, /* The virtual machine to be destroyed */
char **pzErrMsg /* OUT: Write error messages here */
){
** is written into *pzErrMsg. A success code from the prior execution
** is returned.
*/
-int sqlite_reset(
+int sqlite3_reset(
sqlite_vm *pVm, /* The virtual machine to be destroyed */
char **pzErrMsg /* OUT: Write error messages here */
){
** Return a static string that describes the kind of error specified in the
** argument.
*/
-const char *sqlite_error_string(int rc){
+const char *sqlite3_error_string(int rc){
const char *z;
switch( rc ){
case SQLITE_OK: z = "not an error"; break;
** This routine sets the busy callback for an Sqlite database to the
** given callback function with the given argument.
*/
-void sqlite_busy_handler(
+void sqlite3_busy_handler(
sqlite *db,
int (*xBusy)(void*,const char*,int),
void *pArg
** given callback function with the given argument. The progress callback will
** be invoked every nOps opcodes.
*/
-void sqlite_progress_handler(
+void sqlite3_progress_handler(
sqlite *db,
int nOps,
int (*xProgress)(void*),
** This routine installs a default busy handler that waits for the
** specified number of milliseconds before returning 0.
*/
-void sqlite_busy_timeout(sqlite *db, int ms){
+void sqlite3_busy_timeout(sqlite *db, int ms){
if( ms>0 ){
- sqlite_busy_handler(db, sqliteDefaultBusyCallback, (void*)ms);
+ sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)ms);
}else{
- sqlite_busy_handler(db, 0, 0);
+ sqlite3_busy_handler(db, 0, 0);
}
}
/*
** Cause any pending operation to stop at its earliest opportunity.
*/
-void sqlite_interrupt(sqlite *db){
+void sqlite3_interrupt(sqlite *db){
db->flags |= SQLITE_Interrupt;
}
/*
** 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.
**
** string that is exported from SQLite should have already passed through
** sqlite3StrRealloc().
*/
-void sqlite_freemem(void *p){ free(p); }
+void sqlite3_freemem(void *p){ free(p); }
/*
-** Windows systems need functions to call to return the sqlite_version
-** and sqlite_encoding strings since they are unable to access constants
+** Windows systems need functions to call to return the sqlite3_version
+** and sqlite3_encoding strings since they are unable to access constants
** within DLLs.
*/
-const char *sqlite_libversion(void){ return sqlite_version; }
-const char *sqlite_libencoding(void){ return sqlite_encoding; }
+const char *sqlite3_libversion(void){ return sqlite3_version; }
+const char *sqlite3_libencoding(void){ return sqlite3_encoding; }
/*
-** Create new user-defined functions. The sqlite_create_function()
-** routine creates a regular function and sqlite_create_aggregate()
+** Create new user-defined functions. The sqlite3_create_function()
+** routine creates a regular function and sqlite3_create_aggregate()
** creates an aggregate function.
**
** Passing a NULL xFunc argument or NULL xStep and xFinalize arguments
-** disables the function. Calling sqlite_create_function() with the
+** disables the function. Calling sqlite3_create_function() with the
** same name and number of arguments as a prior call to
-** sqlite_create_aggregate() disables the prior call to
-** sqlite_create_aggregate(), and vice versa.
+** sqlite3_create_aggregate() disables the prior call to
+** sqlite3_create_aggregate(), and vice versa.
**
** If nArg is -1 it means that this function will accept any number
** of arguments, including 0. The maximum allowed value of nArg is 127.
*/
-int sqlite_create_function(
+int sqlite3_create_function(
sqlite *db, /* Add the function to this database connection */
const char *zName, /* Name of the function to add */
int nArg, /* Number of arguments */
p->pUserData = pUserData;
return 0;
}
-int sqlite_create_aggregate(
+int sqlite3_create_aggregate(
sqlite *db, /* Add the function to this database connection */
const char *zName, /* Name of the function to add */
int nArg, /* Number of arguments */
** header comment for the prototype of this function in sqlite.h for
** additional information.
*/
-int sqlite_function_type(sqlite *db, const char *zName, int dataType){
+int sqlite3_function_type(sqlite *db, const char *zName, int dataType){
FuncDef *p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName, strlen(zName));
while( p ){
p->dataType = dataType;
**
** A NULL trace function means that no tracing is executes. A non-NULL
** trace is a pointer to a function that is invoked at the start of each
-** sqlite_exec().
+** sqlite3_exec().
*/
-void *sqlite_trace(sqlite *db, void (*xTrace)(void*,const char*), void *pArg){
+void *sqlite3_trace(sqlite *db, void (*xTrace)(void*,const char*), void *pArg){
void *pOld = db->pTraceArg;
db->xTrace = xTrace;
db->pTraceArg = pArg;
** If either function returns non-zero, then the commit becomes a
** rollback.
*/
-void *sqlite_commit_hook(
+void *sqlite3_commit_hook(
sqlite *db, /* Attach the hook to this database */
int (*xCallback)(void*), /* Function to invoke on each commit */
void *pArg /* Argument to the function */
**
*/
int sqlite3_open(const char *filename, sqlite3 **pDb, const char **options){
- *pDb = sqlite_open(filename, 0, &errmsg);
+ *pDb = sqlite3_open(filename, 0, &errmsg);
return (*pDb?SQLITE_OK:SQLITE_ERROR);
}
int sqlite3_open16(const void *filename, sqlite3 **pDb, const char **options){
**
*/
int sqlite3_close(sqlite3 *db){
- return sqlite_close(db);
+ return sqlite3_close(db);
}
/*
const char** pzTail
){
int rc;
- rc = sqlite_compile(db, zSql, pzTail, ppStmt, 0);
+ rc = sqlite3_compile(db, zSql, pzTail, ppStmt, 0);
return rc;
}
int sqlite3_prepare16(
** sqlite3_finalize
*/
int sqlite3_finalize(sqlite3_stmt *stmt){
- return sqlite_finalize(stmt, 0);
+ return sqlite3_finalize(stmt, 0);
}
/*
** sqlite3_reset
*/
int sqlite3_reset(sqlite3_stmt*){
- return sqlite_reset(stmt, 0);
+ return sqlite3_reset(stmt, 0);
}
/*
** sqlite3_step
*/
int sqlite3_step(sqlite3_stmt *pStmt){
- return sqlite_step(pStmt);
+ return sqlite3_step(pStmt);
}
/*
int n,
int eCopy
){
- return sqlite_bind(pStmt, i, zVal, n, eCopy);
+ return sqlite3_bind(pStmt, i, zVal, n, eCopy);
}
int sqlite3_bind_text16(
** sqlite3_bind_null
*/
int sqlite3_bind_null(sqlite3_stmt*, int iParm){
- return sqlite_bind(pStmt, i, 0, 0, 0);
+ return sqlite3_bind(pStmt, i, 0, 0, 0);
}
projects / thirdparty / sqlite.git / commitdiff
