Symaptic: os/persistentdata/persistentstorage/sqlite3api/SQLite/main.c@bde4ae8d615e (annotated)

sl@0	1	/*
sl@0	2	** 2001 September 15
sl@0	3	**
sl@0	4	** The author disclaims copyright to this source code. In place of
sl@0	5	** a legal notice, here is a blessing:
sl@0	6	**
sl@0	7	** May you do good and not evil.
sl@0	8	** May you find forgiveness for yourself and forgive others.
sl@0	9	** May you share freely, never taking more than you give.
sl@0	10	**
sl@0	11	*************************************************************************
sl@0	12	** Main file for the SQLite library. The routines in this file
sl@0	13	** implement the programmer interface to the library. Routines in
sl@0	14	** other files are for internal use by SQLite and should not be
sl@0	15	** accessed by users of the library.
sl@0	16	**
sl@0	17	** $Id: main.c,v 1.502 2008/09/23 17:39:26 danielk1977 Exp $
sl@0	18	*/
sl@0	19	#include "sqliteInt.h"
sl@0	20	#include <ctype.h>
sl@0	21
sl@0	22	#ifdef SQLITE_ENABLE_FTS3
sl@0	23	# include "fts3.h"
sl@0	24	#endif
sl@0	25	#ifdef SQLITE_ENABLE_RTREE
sl@0	26	# include "rtree.h"
sl@0	27	#endif
sl@0	28	#ifdef SQLITE_ENABLE_ICU
sl@0	29	# include "sqliteicu.h"
sl@0	30	#endif
sl@0	31
sl@0	32	/*
sl@0	33	** The version of the library
sl@0	34	*/
sl@0	35	const char sqlite3_version[] = SQLITE_VERSION;
sl@0	36	SQLITE_EXPORT const char *sqlite3_libversion(void){ return sqlite3_version; }
sl@0	37	SQLITE_EXPORT int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
sl@0	38	SQLITE_EXPORT int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
sl@0	39
sl@0	40	#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
sl@0	41	/*
sl@0	42	** If the following function pointer is not NULL and if
sl@0	43	** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
sl@0	44	** I/O active are written using this function. These messages
sl@0	45	** are intended for debugging activity only.
sl@0	46	*/
sl@0	47	void (sqlite3IoTrace)(const char, ...) = 0;
sl@0	48	#endif
sl@0	49
sl@0	50	/*
sl@0	51	** If the following global variable points to a string which is the
sl@0	52	** name of a directory, then that directory will be used to store
sl@0	53	** temporary files.
sl@0	54	**
sl@0	55	** See also the "PRAGMA temp_store_directory" SQL command.
sl@0	56	*/
sl@0	57	char *sqlite3_temp_directory = 0;
sl@0	58
sl@0	59	/*
sl@0	60	** Initialize SQLite.
sl@0	61	**
sl@0	62	** This routine must be called to initialize the memory allocation,
sl@0	63	** VFS, and mutex subsystems prior to doing any serious work with
sl@0	64	** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
sl@0	65	** this routine will be called automatically by key routines such as
sl@0	66	** sqlite3_open().
sl@0	67	**
sl@0	68	** This routine is a no-op except on its very first call for the process,
sl@0	69	** or for the first call after a call to sqlite3_shutdown.
sl@0	70	**
sl@0	71	** The first thread to call this routine runs the initialization to
sl@0	72	** completion. If subsequent threads call this routine before the first
sl@0	73	** thread has finished the initialization process, then the subsequent
sl@0	74	** threads must block until the first thread finishes with the initialization.
sl@0	75	**
sl@0	76	** The first thread might call this routine recursively. Recursive
sl@0	77	** calls to this routine should not block, of course. Otherwise the
sl@0	78	** initialization process would never complete.
sl@0	79	**
sl@0	80	** Let X be the first thread to enter this routine. Let Y be some other
sl@0	81	** thread. Then while the initial invocation of this routine by X is
sl@0	82	** incomplete, it is required that:
sl@0	83	**
sl@0	84	** * Calls to this routine from Y must block until the outer-most
sl@0	85	** call by X completes.
sl@0	86	**
sl@0	87	** * Recursive calls to this routine from thread X return immediately
sl@0	88	** without blocking.
sl@0	89	*/
sl@0	90	SQLITE_EXPORT int sqlite3_initialize(void){
sl@0	91	sqlite3_mutex pMaster; / The main static mutex */
sl@0	92	int rc; /* Result code */
sl@0	93
sl@0	94	#ifdef SQLITE_OMIT_WSD
sl@0	95	rc = sqlite3_wsd_init(4096, 24);
sl@0	96	if( rc!=SQLITE_OK ){
sl@0	97	return rc;
sl@0	98	}
sl@0	99	#endif
sl@0	100
sl@0	101	/* If SQLite is already completely initialized, then this call
sl@0	102	** to sqlite3_initialize() should be a no-op. But the initialization
sl@0	103	** must be complete. So isInit must not be set until the very end
sl@0	104	** of this routine.
sl@0	105	*/
sl@0	106	if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
sl@0	107
sl@0	108	/* Make sure the mutex subsystem is initialized. If unable to
sl@0	109	** initialize the mutex subsystem, return early with the error.
sl@0	110	** If the system is so sick that we are unable to allocate a mutex,
sl@0	111	** there is not much SQLite is going to be able to do.
sl@0	112	**
sl@0	113	** The mutex subsystem must take care of serializing its own
sl@0	114	** initialization.
sl@0	115	*/
sl@0	116	rc = sqlite3MutexInit();
sl@0	117	if( rc ) return rc;
sl@0	118
sl@0	119	/* Initialize the malloc() system and the recursive pInitMutex mutex.
sl@0	120	** This operation is protected by the STATIC_MASTER mutex. Note that
sl@0	121	** MutexAlloc() is called for a static mutex prior to initializing the
sl@0	122	** malloc subsystem - this implies that the allocation of a static
sl@0	123	** mutex must not require support from the malloc subsystem.
sl@0	124	*/
sl@0	125	pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
sl@0	126	sqlite3_mutex_enter(pMaster);
sl@0	127	if( !sqlite3GlobalConfig.isMallocInit ){
sl@0	128	rc = sqlite3MallocInit();
sl@0	129	}
sl@0	130	if( rc==SQLITE_OK ){
sl@0	131	sqlite3GlobalConfig.isMallocInit = 1;
sl@0	132	if( !sqlite3GlobalConfig.pInitMutex ){
sl@0	133	sqlite3GlobalConfig.pInitMutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
sl@0	134	if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){
sl@0	135	rc = SQLITE_NOMEM;
sl@0	136	}
sl@0	137	}
sl@0	138	if( rc==SQLITE_OK )
sl@0	139	sqlite3GlobalConfig.nRefInitMutex++;
sl@0	140	}
sl@0	141	sqlite3_mutex_leave(pMaster);
sl@0	142
sl@0	143	/* If unable to initialize the malloc subsystem, then return early.
sl@0	144	** There is little hope of getting SQLite to run if the malloc
sl@0	145	** subsystem cannot be initialized.
sl@0	146	*/
sl@0	147	if( rc!=SQLITE_OK ){
sl@0	148	return rc;
sl@0	149	}
sl@0	150
sl@0	151	/* Do the rest of the initialization under the recursive mutex so
sl@0	152	** that we will be able to handle recursive calls into
sl@0	153	** sqlite3_initialize(). The recursive calls normally come through
sl@0	154	** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
sl@0	155	** recursive calls might also be possible.
sl@0	156	*/
sl@0	157	sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
sl@0	158	if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){
sl@0	159	FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
sl@0	160	sqlite3GlobalConfig.inProgress = 1;
sl@0	161	memset(pHash, 0, sizeof(sqlite3GlobalFunctions));
sl@0	162	sqlite3RegisterGlobalFunctions();
sl@0	163	rc = sqlite3_os_init();
sl@0	164	if( rc==SQLITE_OK ){
sl@0	165	rc = sqlite3PcacheInitialize();
sl@0	166	sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
sl@0	167	sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
sl@0	168	}
sl@0	169	sqlite3GlobalConfig.inProgress = 0;
sl@0	170	sqlite3GlobalConfig.isInit = (rc==SQLITE_OK ? 1 : 0);
sl@0	171	}
sl@0	172	sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
sl@0	173
sl@0	174	/* Go back under the static mutex and clean up the recursive
sl@0	175	** mutex to prevent a resource leak.
sl@0	176	*/
sl@0	177	sqlite3_mutex_enter(pMaster);
sl@0	178	sqlite3GlobalConfig.nRefInitMutex--;
sl@0	179	if( sqlite3GlobalConfig.nRefInitMutex<=0 ){
sl@0	180	assert( sqlite3GlobalConfig.nRefInitMutex==0 );
sl@0	181	sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
sl@0	182	sqlite3GlobalConfig.pInitMutex = 0;
sl@0	183	}
sl@0	184	sqlite3_mutex_leave(pMaster);
sl@0	185
sl@0	186	/* The following is just a sanity check to make sure SQLite has
sl@0	187	** been compiled correctly. It is important to run this code, but
sl@0	188	** we don't want to run it too often and soak up CPU cycles for no
sl@0	189	** reason. So we run it once during initialization.
sl@0	190	*/
sl@0	191	#ifndef NDEBUG
sl@0	192	/* This section of code's only "output" is via assert() statements. */
sl@0	193	if ( rc==SQLITE_OK ){
sl@0	194	u64 x = (((u64)1)<<63)-1;
sl@0	195	double y;
sl@0	196	assert(sizeof(x)==8);
sl@0	197	assert(sizeof(x)==sizeof(y));
sl@0	198	memcpy(&y, &x, 8);
sl@0	199	assert( sqlite3IsNaN(y) );
sl@0	200	}
sl@0	201	#endif
sl@0	202
sl@0	203	return rc;
sl@0	204	}
sl@0	205
sl@0	206	/*
sl@0	207	** Undo the effects of sqlite3_initialize(). Must not be called while
sl@0	208	** there are outstanding database connections or memory allocations or
sl@0	209	** while any part of SQLite is otherwise in use in any thread. This
sl@0	210	** routine is not threadsafe. Not by a long shot.
sl@0	211	*/
sl@0	212	SQLITE_EXPORT int sqlite3_shutdown(void){
sl@0	213	sqlite3GlobalConfig.isMallocInit = 0;
sl@0	214	sqlite3PcacheShutdown();
sl@0	215	if( sqlite3GlobalConfig.isInit ){
sl@0	216	sqlite3_os_end();
sl@0	217	}
sl@0	218	if( sqlite3GlobalConfig.m.xShutdown ){
sl@0	219	sqlite3MallocEnd();
sl@0	220	}
sl@0	221	if( sqlite3GlobalConfig.mutex.xMutexEnd ){
sl@0	222	sqlite3MutexEnd();
sl@0	223	}
sl@0	224	sqlite3GlobalConfig.isInit = 0;
sl@0	225	return SQLITE_OK;
sl@0	226	}
sl@0	227
sl@0	228	/*
sl@0	229	** This API allows applications to modify the global configuration of
sl@0	230	** the SQLite library at run-time.
sl@0	231	**
sl@0	232	** This routine should only be called when there are no outstanding
sl@0	233	** database connections or memory allocations. This routine is not
sl@0	234	** threadsafe. Failure to heed these warnings can lead to unpredictable
sl@0	235	** behavior.
sl@0	236	*/
sl@0	237	SQLITE_EXPORT int sqlite3_config(int op, ...){
sl@0	238	va_list ap;
sl@0	239	int rc = SQLITE_OK;
sl@0	240
sl@0	241	/* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
sl@0	242	** the SQLite library is in use. */
sl@0	243	if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE;
sl@0	244
sl@0	245	va_start(ap, op);
sl@0	246	switch( op ){
sl@0	247	case SQLITE_CONFIG_SINGLETHREAD: {
sl@0	248	/* Disable all mutexing */
sl@0	249	sqlite3GlobalConfig.bCoreMutex = 0;
sl@0	250	sqlite3GlobalConfig.bFullMutex = 0;
sl@0	251	break;
sl@0	252	}
sl@0	253	case SQLITE_CONFIG_MULTITHREAD: {
sl@0	254	/* Disable mutexing of database connections */
sl@0	255	/* Enable mutexing of core data structures */
sl@0	256	sqlite3GlobalConfig.bCoreMutex = 1;
sl@0	257	sqlite3GlobalConfig.bFullMutex = 0;
sl@0	258	break;
sl@0	259	}
sl@0	260	case SQLITE_CONFIG_SERIALIZED: {
sl@0	261	/* Enable all mutexing */
sl@0	262	sqlite3GlobalConfig.bCoreMutex = 1;
sl@0	263	sqlite3GlobalConfig.bFullMutex = 1;
sl@0	264	break;
sl@0	265	}
sl@0	266	case SQLITE_CONFIG_MALLOC: {
sl@0	267	/* Specify an alternative malloc implementation */
sl@0	268	sqlite3GlobalConfig.m = va_arg(ap, sqlite3_mem_methods);
sl@0	269	break;
sl@0	270	}
sl@0	271	case SQLITE_CONFIG_GETMALLOC: {
sl@0	272	/* Retrieve the current malloc() implementation */
sl@0	273	if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
sl@0	274	va_arg(ap, sqlite3_mem_methods) = sqlite3GlobalConfig.m;
sl@0	275	break;
sl@0	276	}
sl@0	277	case SQLITE_CONFIG_MUTEX: {
sl@0	278	/* Specify an alternative mutex implementation */
sl@0	279	sqlite3GlobalConfig.mutex = va_arg(ap, sqlite3_mutex_methods);
sl@0	280	break;
sl@0	281	}
sl@0	282	case SQLITE_CONFIG_GETMUTEX: {
sl@0	283	/* Retrieve the current mutex implementation */
sl@0	284	va_arg(ap, sqlite3_mutex_methods) = sqlite3GlobalConfig.mutex;
sl@0	285	break;
sl@0	286	}
sl@0	287	case SQLITE_CONFIG_MEMSTATUS: {
sl@0	288	/* Enable or disable the malloc status collection */
sl@0	289	sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
sl@0	290	break;
sl@0	291	}
sl@0	292	case SQLITE_CONFIG_SCRATCH: {
sl@0	293	/* Designate a buffer for scratch memory space */
sl@0	294	sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
sl@0	295	sqlite3GlobalConfig.szScratch = va_arg(ap, int);
sl@0	296	sqlite3GlobalConfig.nScratch = va_arg(ap, int);
sl@0	297	break;
sl@0	298	}
sl@0	299	case SQLITE_CONFIG_PAGECACHE: {
sl@0	300	/* Designate a buffer for scratch memory space */
sl@0	301	sqlite3GlobalConfig.pPage = va_arg(ap, void*);
sl@0	302	sqlite3GlobalConfig.szPage = va_arg(ap, int);
sl@0	303	sqlite3GlobalConfig.nPage = va_arg(ap, int);
sl@0	304	break;
sl@0	305	}
sl@0	306
sl@0	307	#if defined(SQLITE_ENABLE_MEMSYS3) \|\| defined(SQLITE_ENABLE_MEMSYS5)
sl@0	308	case SQLITE_CONFIG_HEAP: {
sl@0	309	/* Designate a buffer for heap memory space */
sl@0	310	sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
sl@0	311	sqlite3GlobalConfig.nHeap = va_arg(ap, int);
sl@0	312	sqlite3GlobalConfig.mnReq = va_arg(ap, int);
sl@0	313
sl@0	314	if( sqlite3GlobalConfig.pHeap==0 ){
sl@0	315	/* If the heap pointer is NULL, then restore the malloc implementation
sl@0	316	** back to NULL pointers too. This will cause the malloc to go
sl@0	317	** back to its default implementation when sqlite3_initialize() is
sl@0	318	** run.
sl@0	319	*/
sl@0	320	memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
sl@0	321	}else{
sl@0	322	/* The heap pointer is not NULL, then install one of the
sl@0	323	** mem5.c/mem3.c methods. If neither ENABLE_MEMSYS3 nor
sl@0	324	** ENABLE_MEMSYS5 is defined, return an error.
sl@0	325	** the default case and return an error.
sl@0	326	*/
sl@0	327	#ifdef SQLITE_ENABLE_MEMSYS3
sl@0	328	sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
sl@0	329	#endif
sl@0	330	#ifdef SQLITE_ENABLE_MEMSYS5
sl@0	331	sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
sl@0	332	#endif
sl@0	333	}
sl@0	334	break;
sl@0	335	}
sl@0	336	#endif
sl@0	337
sl@0	338	#if defined(SQLITE_ENABLE_MEMSYS6)
sl@0	339	case SQLITE_CONFIG_CHUNKALLOC: {
sl@0	340	sqlite3GlobalConfig.nSmall = va_arg(ap, int);
sl@0	341	sqlite3GlobalConfig.m = *sqlite3MemGetMemsys6();
sl@0	342	break;
sl@0	343	}
sl@0	344	#endif
sl@0	345
sl@0	346	case SQLITE_CONFIG_LOOKASIDE: {
sl@0	347	sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
sl@0	348	sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
sl@0	349	break;
sl@0	350	}
sl@0	351
sl@0	352	default: {
sl@0	353	rc = SQLITE_ERROR;
sl@0	354	break;
sl@0	355	}
sl@0	356	}
sl@0	357	va_end(ap);
sl@0	358	return rc;
sl@0	359	}
sl@0	360
sl@0	361	/*
sl@0	362	** Set up the lookaside buffers for a database connection.
sl@0	363	** Return SQLITE_OK on success.
sl@0	364	** If lookaside is already active, return SQLITE_BUSY.
sl@0	365	**
sl@0	366	** The sz parameter is the number of bytes in each lookaside slot.
sl@0	367	** The cnt parameter is the number of slots. If pStart is NULL the
sl@0	368	** space for the lookaside memory is obtained from sqlite3_malloc().
sl@0	369	** If pStart is not NULL then it is sz*cnt bytes of memory to use for
sl@0	370	** the lookaside memory.
sl@0	371	*/
sl@0	372	static int setupLookaside(sqlite3 db, void pBuf, int sz, int cnt){
sl@0	373	void *pStart;
sl@0	374	if( db->lookaside.nOut ){
sl@0	375	return SQLITE_BUSY;
sl@0	376	}
sl@0	377	if( sz<0 ) sz = 0;
sl@0	378	if( cnt<0 ) cnt = 0;
sl@0	379	if( pBuf==0 ){
sl@0	380	sz = (sz + 7)&~7;
sl@0	381	sqlite3BeginBenignMalloc();
sl@0	382	pStart = sqlite3Malloc( sz*cnt );
sl@0	383	sqlite3EndBenignMalloc();
sl@0	384	}else{
sl@0	385	sz = sz&~7;
sl@0	386	pStart = pBuf;
sl@0	387	}
sl@0	388	if( db->lookaside.bMalloced ){
sl@0	389	sqlite3_free(db->lookaside.pStart);
sl@0	390	}
sl@0	391	db->lookaside.pStart = pStart;
sl@0	392	db->lookaside.pFree = 0;
sl@0	393	db->lookaside.sz = sz;
sl@0	394	db->lookaside.bMalloced = pBuf==0;
sl@0	395	if( pStart ){
sl@0	396	int i;
sl@0	397	LookasideSlot *p;
sl@0	398	p = (LookasideSlot*)pStart;
sl@0	399	for(i=cnt-1; i>=0; i--){
sl@0	400	p->pNext = db->lookaside.pFree;
sl@0	401	db->lookaside.pFree = p;
sl@0	402	p = (LookasideSlot)&((u8)p)[sz];
sl@0	403	}
sl@0	404	db->lookaside.pEnd = p;
sl@0	405	db->lookaside.bEnabled = 1;
sl@0	406	}else{
sl@0	407	db->lookaside.pEnd = 0;
sl@0	408	db->lookaside.bEnabled = 0;
sl@0	409	}
sl@0	410	return SQLITE_OK;
sl@0	411	}
sl@0	412
sl@0	413	/*
sl@0	414	** Configuration settings for an individual database connection
sl@0	415	*/
sl@0	416	SQLITE_EXPORT int sqlite3_db_config(sqlite3 *db, int op, ...){
sl@0	417	va_list ap;
sl@0	418	int rc;
sl@0	419	va_start(ap, op);
sl@0	420	switch( op ){
sl@0	421	case SQLITE_DBCONFIG_LOOKASIDE: {
sl@0	422	void pBuf = va_arg(ap, void);
sl@0	423	int sz = va_arg(ap, int);
sl@0	424	int cnt = va_arg(ap, int);
sl@0	425	rc = setupLookaside(db, pBuf, sz, cnt);
sl@0	426	break;
sl@0	427	}
sl@0	428	default: {
sl@0	429	rc = SQLITE_ERROR;
sl@0	430	break;
sl@0	431	}
sl@0	432	}
sl@0	433	va_end(ap);
sl@0	434	return rc;
sl@0	435	}
sl@0	436
sl@0	437	/*
sl@0	438	** Routine needed to support the testcase() macro.
sl@0	439	*/
sl@0	440	#ifdef SQLITE_COVERAGE_TEST
sl@0	441	void sqlite3Coverage(int x){
sl@0	442	static int dummy = 0;
sl@0	443	dummy += x;
sl@0	444	}
sl@0	445	#endif
sl@0	446
sl@0	447
sl@0	448	/*
sl@0	449	** Return true if the buffer z[0..n-1] contains all spaces.
sl@0	450	*/
sl@0	451	static int allSpaces(const char *z, int n){
sl@0	452	while( n>0 && z[n-1]==' ' ){ n--; }
sl@0	453	return n==0;
sl@0	454	}
sl@0	455
sl@0	456	/*
sl@0	457	** This is the default collating function named "BINARY" which is always
sl@0	458	** available.
sl@0	459	**
sl@0	460	** If the padFlag argument is not NULL then space padding at the end
sl@0	461	** of strings is ignored. This implements the RTRIM collation.
sl@0	462	*/
sl@0	463	static int binCollFunc(
sl@0	464	void *padFlag,
sl@0	465	int nKey1, const void *pKey1,
sl@0	466	int nKey2, const void *pKey2
sl@0	467	){
sl@0	468	int rc, n;
sl@0	469	n = nKey1<nKey2 ? nKey1 : nKey2;
sl@0	470	rc = memcmp(pKey1, pKey2, n);
sl@0	471	if( rc==0 ){
sl@0	472	if( padFlag
sl@0	473	&& allSpaces(((char*)pKey1)+n, nKey1-n)
sl@0	474	&& allSpaces(((char*)pKey2)+n, nKey2-n)
sl@0	475	){
sl@0	476	/* Leave rc unchanged at 0 */
sl@0	477	}else{
sl@0	478	rc = nKey1 - nKey2;
sl@0	479	}
sl@0	480	}
sl@0	481	return rc;
sl@0	482	}
sl@0	483
sl@0	484	/*
sl@0	485	** Another built-in collating sequence: NOCASE.
sl@0	486	**
sl@0	487	** This collating sequence is intended to be used for "case independant
sl@0	488	** comparison". SQLite's knowledge of upper and lower case equivalents
sl@0	489	** extends only to the 26 characters used in the English language.
sl@0	490	**
sl@0	491	** At the moment there is only a UTF-8 implementation.
sl@0	492	*/
sl@0	493	static int nocaseCollatingFunc(
sl@0	494	void *NotUsed,
sl@0	495	int nKey1, const void *pKey1,
sl@0	496	int nKey2, const void *pKey2
sl@0	497	){
sl@0	498	int r = sqlite3StrNICmp(
sl@0	499	(const char )pKey1, (const char )pKey2, (nKey1<nKey2)?nKey1:nKey2);
sl@0	500	if( 0==r ){
sl@0	501	r = nKey1-nKey2;
sl@0	502	}
sl@0	503	return r;
sl@0	504	}
sl@0	505
sl@0	506	/*
sl@0	507	** Return the ROWID of the most recent insert
sl@0	508	*/
sl@0	509	SQLITE_EXPORT sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
sl@0	510	return db->lastRowid;
sl@0	511	}
sl@0	512
sl@0	513	/*
sl@0	514	** Return the number of changes in the most recent call to sqlite3_exec().
sl@0	515	*/
sl@0	516	SQLITE_EXPORT int sqlite3_changes(sqlite3 *db){
sl@0	517	return db->nChange;
sl@0	518	}
sl@0	519
sl@0	520	/*
sl@0	521	** Return the number of changes since the database handle was opened.
sl@0	522	*/
sl@0	523	SQLITE_EXPORT int sqlite3_total_changes(sqlite3 *db){
sl@0	524	return db->nTotalChange;
sl@0	525	}
sl@0	526
sl@0	527	/*
sl@0	528	** Close an existing SQLite database
sl@0	529	*/
sl@0	530	SQLITE_EXPORT int sqlite3_close(sqlite3 *db){
sl@0	531	HashElem *i;
sl@0	532	int j;
sl@0	533
sl@0	534	if( !db ){
sl@0	535	return SQLITE_OK;
sl@0	536	}
sl@0	537	if( !sqlite3SafetyCheckSickOrOk(db) ){
sl@0	538	return SQLITE_MISUSE;
sl@0	539	}
sl@0	540	sqlite3_mutex_enter(db->mutex);
sl@0	541
sl@0	542	#ifdef SQLITE_SSE
sl@0	543	{
sl@0	544	extern void sqlite3SseCleanup(sqlite3*);
sl@0	545	sqlite3SseCleanup(db);
sl@0	546	}
sl@0	547	#endif
sl@0	548
sl@0	549	sqlite3ResetInternalSchema(db, 0);
sl@0	550
sl@0	551	/* If a transaction is open, the ResetInternalSchema() call above
sl@0	552	** will not have called the xDisconnect() method on any virtual
sl@0	553	** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
sl@0	554	** call will do so. We need to do this before the check for active
sl@0	555	** SQL statements below, as the v-table implementation may be storing
sl@0	556	** some prepared statements internally.
sl@0	557	*/
sl@0	558	sqlite3VtabRollback(db);
sl@0	559
sl@0	560	/* If there are any outstanding VMs, return SQLITE_BUSY. */
sl@0	561	if( db->pVdbe ){
sl@0	562	sqlite3Error(db, SQLITE_BUSY,
sl@0	563	"Unable to close due to unfinalised statements");
sl@0	564	sqlite3_mutex_leave(db->mutex);
sl@0	565	return SQLITE_BUSY;
sl@0	566	}
sl@0	567	assert( sqlite3SafetyCheckSickOrOk(db) );
sl@0	568
sl@0	569	for(j=0; j<db->nDb; j++){
sl@0	570	struct Db *pDb = &db->aDb[j];
sl@0	571	if( pDb->pBt ){
sl@0	572	sqlite3BtreeClose(pDb->pBt);
sl@0	573	pDb->pBt = 0;
sl@0	574	if( j!=1 ){
sl@0	575	pDb->pSchema = 0;
sl@0	576	}
sl@0	577	}
sl@0	578	}
sl@0	579	sqlite3ResetInternalSchema(db, 0);
sl@0	580	assert( db->nDb<=2 );
sl@0	581	assert( db->aDb==db->aDbStatic );
sl@0	582	for(j=0; j<ArraySize(db->aFunc.a); j++){
sl@0	583	FuncDef pNext, pHash, *p;
sl@0	584	for(p=db->aFunc.a[j]; p; p=pHash){
sl@0	585	pHash = p->pHash;
sl@0	586	while( p ){
sl@0	587	pNext = p->pNext;
sl@0	588	sqlite3DbFree(db, p);
sl@0	589	p = pNext;
sl@0	590	}
sl@0	591	}
sl@0	592	}
sl@0	593	for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
sl@0	594	CollSeq pColl = (CollSeq )sqliteHashData(i);
sl@0	595	/* Invoke any destructors registered for collation sequence user data. */
sl@0	596	for(j=0; j<3; j++){
sl@0	597	if( pColl[j].xDel ){
sl@0	598	pColl[j].xDel(pColl[j].pUser);
sl@0	599	}
sl@0	600	}
sl@0	601	sqlite3DbFree(db, pColl);
sl@0	602	}
sl@0	603	sqlite3HashClear(&db->aCollSeq);
sl@0	604	#ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0	605	for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
sl@0	606	Module pMod = (Module )sqliteHashData(i);
sl@0	607	if( pMod->xDestroy ){
sl@0	608	pMod->xDestroy(pMod->pAux);
sl@0	609	}
sl@0	610	sqlite3DbFree(db, pMod);
sl@0	611	}
sl@0	612	sqlite3HashClear(&db->aModule);
sl@0	613	#endif
sl@0	614
sl@0	615	sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
sl@0	616	if( db->pErr ){
sl@0	617	sqlite3ValueFree(db->pErr);
sl@0	618	}
sl@0	619	sqlite3CloseExtensions(db);
sl@0	620
sl@0	621	db->magic = SQLITE_MAGIC_ERROR;
sl@0	622
sl@0	623	/* The temp-database schema is allocated differently from the other schema
sl@0	624	** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
sl@0	625	** So it needs to be freed here. Todo: Why not roll the temp schema into
sl@0	626	** the same sqliteMalloc() as the one that allocates the database
sl@0	627	** structure?
sl@0	628	*/
sl@0	629	sqlite3DbFree(db, db->aDb[1].pSchema);
sl@0	630	sqlite3_mutex_leave(db->mutex);
sl@0	631	db->magic = SQLITE_MAGIC_CLOSED;
sl@0	632	sqlite3_mutex_free(db->mutex);
sl@0	633	if( db->lookaside.bMalloced ){
sl@0	634	sqlite3_free(db->lookaside.pStart);
sl@0	635	}
sl@0	636	sqlite3_free(db);
sl@0	637	return SQLITE_OK;
sl@0	638	}
sl@0	639
sl@0	640	/*
sl@0	641	** Rollback all database files.
sl@0	642	*/
sl@0	643	void sqlite3RollbackAll(sqlite3 *db){
sl@0	644	int i;
sl@0	645	int inTrans = 0;
sl@0	646	assert( sqlite3_mutex_held(db->mutex) );
sl@0	647	sqlite3BeginBenignMalloc();
sl@0	648	for(i=0; i<db->nDb; i++){
sl@0	649	if( db->aDb[i].pBt ){
sl@0	650	if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
sl@0	651	inTrans = 1;
sl@0	652	}
sl@0	653	sqlite3BtreeRollback(db->aDb[i].pBt);
sl@0	654	db->aDb[i].inTrans = 0;
sl@0	655	}
sl@0	656	}
sl@0	657	sqlite3VtabRollback(db);
sl@0	658	sqlite3EndBenignMalloc();
sl@0	659
sl@0	660	if( db->flags&SQLITE_InternChanges ){
sl@0	661	sqlite3ExpirePreparedStatements(db);
sl@0	662	sqlite3ResetInternalSchema(db, 0);
sl@0	663	}
sl@0	664
sl@0	665	/* If one has been configured, invoke the rollback-hook callback */
sl@0	666	if( db->xRollbackCallback && (inTrans \|\| !db->autoCommit) ){
sl@0	667	db->xRollbackCallback(db->pRollbackArg);
sl@0	668	}
sl@0	669	}
sl@0	670
sl@0	671	/*
sl@0	672	** Return a static string that describes the kind of error specified in the
sl@0	673	** argument.
sl@0	674	*/
sl@0	675	const char *sqlite3ErrStr(int rc){
sl@0	676	const char *z;
sl@0	677	switch( rc & 0xff ){
sl@0	678	case SQLITE_ROW:
sl@0	679	case SQLITE_DONE:
sl@0	680	case SQLITE_OK: z = "not an error"; break;
sl@0	681	case SQLITE_ERROR: z = "SQL logic error or missing database"; break;
sl@0	682	case SQLITE_PERM: z = "access permission denied"; break;
sl@0	683	case SQLITE_ABORT: z = "callback requested query abort"; break;
sl@0	684	case SQLITE_BUSY: z = "database is locked"; break;
sl@0	685	case SQLITE_LOCKED: z = "database table is locked"; break;
sl@0	686	case SQLITE_NOMEM: z = "out of memory"; break;
sl@0	687	case SQLITE_READONLY: z = "attempt to write a readonly database"; break;
sl@0	688	case SQLITE_INTERRUPT: z = "interrupted"; break;
sl@0	689	case SQLITE_IOERR: z = "disk I/O error"; break;
sl@0	690	case SQLITE_CORRUPT: z = "database disk image is malformed"; break;
sl@0	691	case SQLITE_FULL: z = "database or disk is full"; break;
sl@0	692	case SQLITE_CANTOPEN: z = "unable to open database file"; break;
sl@0	693	case SQLITE_EMPTY: z = "table contains no data"; break;
sl@0	694	case SQLITE_SCHEMA: z = "database schema has changed"; break;
sl@0	695	case SQLITE_TOOBIG: z = "String or BLOB exceeded size limit"; break;
sl@0	696	case SQLITE_CONSTRAINT: z = "constraint failed"; break;
sl@0	697	case SQLITE_MISMATCH: z = "datatype mismatch"; break;
sl@0	698	case SQLITE_MISUSE: z = "library routine called out of sequence";break;
sl@0	699	case SQLITE_NOLFS: z = "large file support is disabled"; break;
sl@0	700	case SQLITE_AUTH: z = "authorization denied"; break;
sl@0	701	case SQLITE_FORMAT: z = "auxiliary database format error"; break;
sl@0	702	case SQLITE_RANGE: z = "bind or column index out of range"; break;
sl@0	703	case SQLITE_NOTADB: z = "file is encrypted or is not a database";break;
sl@0	704	default: z = "unknown error"; break;
sl@0	705	}
sl@0	706	return z;
sl@0	707	}
sl@0	708
sl@0	709	/*
sl@0	710	** This routine implements a busy callback that sleeps and tries
sl@0	711	** again until a timeout value is reached. The timeout value is
sl@0	712	** an integer number of milliseconds passed in as the first
sl@0	713	** argument.
sl@0	714	*/
sl@0	715	static int sqliteDefaultBusyCallback(
sl@0	716	void ptr, / Database connection */
sl@0	717	int count /* Number of times table has been busy */
sl@0	718	){
sl@0	719	#if SQLITE_OS_WIN \|\| (defined(HAVE_USLEEP) && HAVE_USLEEP)
sl@0	720	static const u8 delays[] =
sl@0	721	{ 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
sl@0	722	static const u8 totals[] =
sl@0	723	{ 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
sl@0	724	# define NDELAY (sizeof(delays)/sizeof(delays[0]))
sl@0	725	sqlite3 db = (sqlite3 )ptr;
sl@0	726	int timeout = db->busyTimeout;
sl@0	727	int delay, prior;
sl@0	728
sl@0	729	assert( count>=0 );
sl@0	730	if( count < NDELAY ){
sl@0	731	delay = delays[count];
sl@0	732	prior = totals[count];
sl@0	733	}else{
sl@0	734	delay = delays[NDELAY-1];
sl@0	735	prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
sl@0	736	}
sl@0	737	if( prior + delay > timeout ){
sl@0	738	delay = timeout - prior;
sl@0	739	if( delay<=0 ) return 0;
sl@0	740	}
sl@0	741	sqlite3OsSleep(db->pVfs, delay*1000);
sl@0	742	return 1;
sl@0	743	#else
sl@0	744	sqlite3 db = (sqlite3 )ptr;
sl@0	745	int timeout = ((sqlite3 *)ptr)->busyTimeout;
sl@0	746	if( (count+1)*1000 > timeout ){
sl@0	747	return 0;
sl@0	748	}
sl@0	749	sqlite3OsSleep(db->pVfs, 1000000);
sl@0	750	return 1;
sl@0	751	#endif
sl@0	752	}
sl@0	753
sl@0	754	/*
sl@0	755	** Invoke the given busy handler.
sl@0	756	**
sl@0	757	** This routine is called when an operation failed with a lock.
sl@0	758	** If this routine returns non-zero, the lock is retried. If it
sl@0	759	** returns 0, the operation aborts with an SQLITE_BUSY error.
sl@0	760	*/
sl@0	761	int sqlite3InvokeBusyHandler(BusyHandler *p){
sl@0	762	int rc;
sl@0	763	if( NEVER(p==0) \|\| p->xFunc==0 \|\| p->nBusy<0 ) return 0;
sl@0	764	rc = p->xFunc(p->pArg, p->nBusy);
sl@0	765	if( rc==0 ){
sl@0	766	p->nBusy = -1;
sl@0	767	}else{
sl@0	768	p->nBusy++;
sl@0	769	}
sl@0	770	return rc;
sl@0	771	}
sl@0	772
sl@0	773	/*
sl@0	774	** This routine sets the busy callback for an Sqlite database to the
sl@0	775	** given callback function with the given argument.
sl@0	776	*/
sl@0	777	SQLITE_EXPORT int sqlite3_busy_handler(
sl@0	778	sqlite3 *db,
sl@0	779	int (xBusy)(void,int),
sl@0	780	void *pArg
sl@0	781	){
sl@0	782	sqlite3_mutex_enter(db->mutex);
sl@0	783	db->busyHandler.xFunc = xBusy;
sl@0	784	db->busyHandler.pArg = pArg;
sl@0	785	db->busyHandler.nBusy = 0;
sl@0	786	sqlite3_mutex_leave(db->mutex);
sl@0	787	return SQLITE_OK;
sl@0	788	}
sl@0	789
sl@0	790	#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
sl@0	791	/*
sl@0	792	** This routine sets the progress callback for an Sqlite database to the
sl@0	793	** given callback function with the given argument. The progress callback will
sl@0	794	** be invoked every nOps opcodes.
sl@0	795	*/
sl@0	796	SQLITE_EXPORT void sqlite3_progress_handler(
sl@0	797	sqlite3 *db,
sl@0	798	int nOps,
sl@0	799	int (xProgress)(void),
sl@0	800	void *pArg
sl@0	801	){
sl@0	802	sqlite3_mutex_enter(db->mutex);
sl@0	803	if( nOps>0 ){
sl@0	804	db->xProgress = xProgress;
sl@0	805	db->nProgressOps = nOps;
sl@0	806	db->pProgressArg = pArg;
sl@0	807	}else{
sl@0	808	db->xProgress = 0;
sl@0	809	db->nProgressOps = 0;
sl@0	810	db->pProgressArg = 0;
sl@0	811	}
sl@0	812	sqlite3_mutex_leave(db->mutex);
sl@0	813	}
sl@0	814	#endif
sl@0	815
sl@0	816
sl@0	817	/*
sl@0	818	** This routine installs a default busy handler that waits for the
sl@0	819	** specified number of milliseconds before returning 0.
sl@0	820	*/
sl@0	821	SQLITE_EXPORT int sqlite3_busy_timeout(sqlite3 *db, int ms){
sl@0	822	if( ms>0 ){
sl@0	823	db->busyTimeout = ms;
sl@0	824	sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
sl@0	825	}else{
sl@0	826	sqlite3_busy_handler(db, 0, 0);
sl@0	827	}
sl@0	828	return SQLITE_OK;
sl@0	829	}
sl@0	830
sl@0	831	/*
sl@0	832	** Cause any pending operation to stop at its earliest opportunity.
sl@0	833	*/
sl@0	834	SQLITE_EXPORT void sqlite3_interrupt(sqlite3 *db){
sl@0	835	db->u1.isInterrupted = 1;
sl@0	836	}
sl@0	837
sl@0	838
sl@0	839	/*
sl@0	840	** This function is exactly the same as sqlite3_create_function(), except
sl@0	841	** that it is designed to be called by internal code. The difference is
sl@0	842	** that if a malloc() fails in sqlite3_create_function(), an error code
sl@0	843	** is returned and the mallocFailed flag cleared.
sl@0	844	*/
sl@0	845	int sqlite3CreateFunc(
sl@0	846	sqlite3 *db,
sl@0	847	const char *zFunctionName,
sl@0	848	int nArg,
sl@0	849	int enc,
sl@0	850	void *pUserData,
sl@0	851	void (xFunc)(sqlite3_context,int,sqlite3_value **),
sl@0	852	void (xStep)(sqlite3_context,int,sqlite3_value **),
sl@0	853	void (xFinal)(sqlite3_context)
sl@0	854	){
sl@0	855	FuncDef *p;
sl@0	856	int nName;
sl@0	857
sl@0	858	assert( sqlite3_mutex_held(db->mutex) );
sl@0	859	if( zFunctionName==0 \|\|
sl@0	860	(xFunc && (xFinal \|\| xStep)) \|\|
sl@0	861	(!xFunc && (xFinal && !xStep)) \|\|
sl@0	862	(!xFunc && (!xFinal && xStep)) \|\|
sl@0	863	(nArg<-1 \|\| nArg>SQLITE_MAX_FUNCTION_ARG) \|\|
sl@0	864	(255<(nName = sqlite3Strlen(db, zFunctionName))) ){
sl@0	865	sqlite3Error(db, SQLITE_ERROR, "bad parameters");
sl@0	866	return SQLITE_ERROR;
sl@0	867	}
sl@0	868
sl@0	869	#ifndef SQLITE_OMIT_UTF16
sl@0	870	/* If SQLITE_UTF16 is specified as the encoding type, transform this
sl@0	871	** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
sl@0	872	** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
sl@0	873	**
sl@0	874	** If SQLITE_ANY is specified, add three versions of the function
sl@0	875	** to the hash table.
sl@0	876	*/
sl@0	877	if( enc==SQLITE_UTF16 ){
sl@0	878	enc = SQLITE_UTF16NATIVE;
sl@0	879	}else if( enc==SQLITE_ANY ){
sl@0	880	int rc;
sl@0	881	rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
sl@0	882	pUserData, xFunc, xStep, xFinal);
sl@0	883	if( rc==SQLITE_OK ){
sl@0	884	rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
sl@0	885	pUserData, xFunc, xStep, xFinal);
sl@0	886	}
sl@0	887	if( rc!=SQLITE_OK ){
sl@0	888	return rc;
sl@0	889	}
sl@0	890	enc = SQLITE_UTF16BE;
sl@0	891	}
sl@0	892	#else
sl@0	893	enc = SQLITE_UTF8;
sl@0	894	#endif
sl@0	895
sl@0	896	/* Check if an existing function is being overridden or deleted. If so,
sl@0	897	** and there are active VMs, then return SQLITE_BUSY. If a function
sl@0	898	** is being overridden/deleted but there are no active VMs, allow the
sl@0	899	** operation to continue but invalidate all precompiled statements.
sl@0	900	*/
sl@0	901	p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0);
sl@0	902	if( p && p->iPrefEnc==enc && p->nArg==nArg ){
sl@0	903	if( db->activeVdbeCnt ){
sl@0	904	sqlite3Error(db, SQLITE_BUSY,
sl@0	905	"Unable to delete/modify user-function due to active statements");
sl@0	906	assert( !db->mallocFailed );
sl@0	907	return SQLITE_BUSY;
sl@0	908	}else{
sl@0	909	sqlite3ExpirePreparedStatements(db);
sl@0	910	}
sl@0	911	}
sl@0	912
sl@0	913	p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
sl@0	914	assert(p \|\| db->mallocFailed);
sl@0	915	if( !p ){
sl@0	916	return SQLITE_NOMEM;
sl@0	917	}
sl@0	918	p->flags = 0;
sl@0	919	p->xFunc = xFunc;
sl@0	920	p->xStep = xStep;
sl@0	921	p->xFinalize = xFinal;
sl@0	922	p->pUserData = pUserData;
sl@0	923	p->nArg = nArg;
sl@0	924	return SQLITE_OK;
sl@0	925	}
sl@0	926
sl@0	927	/*
sl@0	928	** Create new user functions.
sl@0	929	*/
sl@0	930	SQLITE_EXPORT int sqlite3_create_function(
sl@0	931	sqlite3 *db,
sl@0	932	const char *zFunctionName,
sl@0	933	int nArg,
sl@0	934	int enc,
sl@0	935	void *p,
sl@0	936	void (xFunc)(sqlite3_context,int,sqlite3_value **),
sl@0	937	void (xStep)(sqlite3_context,int,sqlite3_value **),
sl@0	938	void (xFinal)(sqlite3_context)
sl@0	939	){
sl@0	940	int rc;
sl@0	941	sqlite3_mutex_enter(db->mutex);
sl@0	942	rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
sl@0	943	rc = sqlite3ApiExit(db, rc);
sl@0	944	sqlite3_mutex_leave(db->mutex);
sl@0	945	return rc;
sl@0	946	}
sl@0	947
sl@0	948	#ifndef SQLITE_OMIT_UTF16
sl@0	949	SQLITE_EXPORT int sqlite3_create_function16(
sl@0	950	sqlite3 *db,
sl@0	951	const void *zFunctionName,
sl@0	952	int nArg,
sl@0	953	int eTextRep,
sl@0	954	void *p,
sl@0	955	void (xFunc)(sqlite3_context,int,sqlite3_value**),
sl@0	956	void (xStep)(sqlite3_context,int,sqlite3_value**),
sl@0	957	void (xFinal)(sqlite3_context)
sl@0	958	){
sl@0	959	int rc;
sl@0	960	char *zFunc8;
sl@0	961	sqlite3_mutex_enter(db->mutex);
sl@0	962	assert( !db->mallocFailed );
sl@0	963	zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
sl@0	964	rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
sl@0	965	sqlite3DbFree(db, zFunc8);
sl@0	966	rc = sqlite3ApiExit(db, rc);
sl@0	967	sqlite3_mutex_leave(db->mutex);
sl@0	968	return rc;
sl@0	969	}
sl@0	970	#endif
sl@0	971
sl@0	972
sl@0	973	/*
sl@0	974	** Declare that a function has been overloaded by a virtual table.
sl@0	975	**
sl@0	976	** If the function already exists as a regular global function, then
sl@0	977	** this routine is a no-op. If the function does not exist, then create
sl@0	978	** a new one that always throws a run-time error.
sl@0	979	**
sl@0	980	** When virtual tables intend to provide an overloaded function, they
sl@0	981	** should call this routine to make sure the global function exists.
sl@0	982	** A global function must exist in order for name resolution to work
sl@0	983	** properly.
sl@0	984	*/
sl@0	985	SQLITE_EXPORT int sqlite3_overload_function(
sl@0	986	sqlite3 *db,
sl@0	987	const char *zName,
sl@0	988	int nArg
sl@0	989	){
sl@0	990	int nName = sqlite3Strlen(db, zName);
sl@0	991	int rc;
sl@0	992	sqlite3_mutex_enter(db->mutex);
sl@0	993	if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
sl@0	994	sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
sl@0	995	0, sqlite3InvalidFunction, 0, 0);
sl@0	996	}
sl@0	997	rc = sqlite3ApiExit(db, SQLITE_OK);
sl@0	998	sqlite3_mutex_leave(db->mutex);
sl@0	999	return rc;
sl@0	1000	}
sl@0	1001
sl@0	1002	#ifndef SQLITE_OMIT_TRACE
sl@0	1003	/*
sl@0	1004	** Register a trace function. The pArg from the previously registered trace
sl@0	1005	** is returned.
sl@0	1006	**
sl@0	1007	** A NULL trace function means that no tracing is executes. A non-NULL
sl@0	1008	** trace is a pointer to a function that is invoked at the start of each
sl@0	1009	** SQL statement.
sl@0	1010	*/
sl@0	1011	SQLITE_EXPORT void sqlite3_trace(sqlite3 db, void (xTrace)(void,const char), void pArg){
sl@0	1012	void *pOld;
sl@0	1013	sqlite3_mutex_enter(db->mutex);
sl@0	1014	pOld = db->pTraceArg;
sl@0	1015	db->xTrace = xTrace;
sl@0	1016	db->pTraceArg = pArg;
sl@0	1017	sqlite3_mutex_leave(db->mutex);
sl@0	1018	return pOld;
sl@0	1019	}
sl@0	1020	/*
sl@0	1021	** Register a profile function. The pArg from the previously registered
sl@0	1022	** profile function is returned.
sl@0	1023	**
sl@0	1024	** A NULL profile function means that no profiling is executes. A non-NULL
sl@0	1025	** profile is a pointer to a function that is invoked at the conclusion of
sl@0	1026	** each SQL statement that is run.
sl@0	1027	*/
sl@0	1028	SQLITE_EXPORT void *sqlite3_profile(
sl@0	1029	sqlite3 *db,
sl@0	1030	void (xProfile)(void,const char*,sqlite_uint64),
sl@0	1031	void *pArg
sl@0	1032	){
sl@0	1033	void *pOld;
sl@0	1034	sqlite3_mutex_enter(db->mutex);
sl@0	1035	pOld = db->pProfileArg;
sl@0	1036	db->xProfile = xProfile;
sl@0	1037	db->pProfileArg = pArg;
sl@0	1038	sqlite3_mutex_leave(db->mutex);
sl@0	1039	return pOld;
sl@0	1040	}
sl@0	1041	#endif /* SQLITE_OMIT_TRACE */
sl@0	1042
sl@0	1043	/* EXPERIMENTAL *
sl@0	1044	**
sl@0	1045	** Register a function to be invoked when a transaction comments.
sl@0	1046	** If the invoked function returns non-zero, then the commit becomes a
sl@0	1047	** rollback.
sl@0	1048	*/
sl@0	1049	SQLITE_EXPORT void *sqlite3_commit_hook(
sl@0	1050	sqlite3 db, / Attach the hook to this database */
sl@0	1051	int (xCallback)(void), /* Function to invoke on each commit */
sl@0	1052	void pArg / Argument to the function */
sl@0	1053	){
sl@0	1054	void *pOld;
sl@0	1055	sqlite3_mutex_enter(db->mutex);
sl@0	1056	pOld = db->pCommitArg;
sl@0	1057	db->xCommitCallback = xCallback;
sl@0	1058	db->pCommitArg = pArg;
sl@0	1059	sqlite3_mutex_leave(db->mutex);
sl@0	1060	return pOld;
sl@0	1061	}
sl@0	1062
sl@0	1063	/*
sl@0	1064	** Register a callback to be invoked each time a row is updated,
sl@0	1065	** inserted or deleted using this database connection.
sl@0	1066	*/
sl@0	1067	SQLITE_EXPORT void *sqlite3_update_hook(
sl@0	1068	sqlite3 db, / Attach the hook to this database */
sl@0	1069	void (xCallback)(void,int,char const ,char const ,sqlite_int64),
sl@0	1070	void pArg / Argument to the function */
sl@0	1071	){
sl@0	1072	void *pRet;
sl@0	1073	sqlite3_mutex_enter(db->mutex);
sl@0	1074	pRet = db->pUpdateArg;
sl@0	1075	db->xUpdateCallback = xCallback;
sl@0	1076	db->pUpdateArg = pArg;
sl@0	1077	sqlite3_mutex_leave(db->mutex);
sl@0	1078	return pRet;
sl@0	1079	}
sl@0	1080
sl@0	1081	/*
sl@0	1082	** Register a callback to be invoked each time a transaction is rolled
sl@0	1083	** back by this database connection.
sl@0	1084	*/
sl@0	1085	SQLITE_EXPORT void *sqlite3_rollback_hook(
sl@0	1086	sqlite3 db, / Attach the hook to this database */
sl@0	1087	void (xCallback)(void), /* Callback function */
sl@0	1088	void pArg / Argument to the function */
sl@0	1089	){
sl@0	1090	void *pRet;
sl@0	1091	sqlite3_mutex_enter(db->mutex);
sl@0	1092	pRet = db->pRollbackArg;
sl@0	1093	db->xRollbackCallback = xCallback;
sl@0	1094	db->pRollbackArg = pArg;
sl@0	1095	sqlite3_mutex_leave(db->mutex);
sl@0	1096	return pRet;
sl@0	1097	}
sl@0	1098
sl@0	1099	/*
sl@0	1100	** This routine is called to create a connection to a database BTree
sl@0	1101	** driver. If zFilename is the name of a file, then that file is
sl@0	1102	** opened and used. If zFilename is the magic name ":memory:" then
sl@0	1103	** the database is stored in memory (and is thus forgotten as soon as
sl@0	1104	** the connection is closed.) If zFilename is NULL then the database
sl@0	1105	** is a "virtual" database for transient use only and is deleted as
sl@0	1106	** soon as the connection is closed.
sl@0	1107	**
sl@0	1108	** A virtual database can be either a disk file (that is automatically
sl@0	1109	** deleted when the file is closed) or it an be held entirely in memory,
sl@0	1110	** depending on the values of the SQLITE_TEMP_STORE compile-time macro and the
sl@0	1111	** db->temp_store variable, according to the following chart:
sl@0	1112	**
sl@0	1113	** SQLITE_TEMP_STORE db->temp_store Location of temporary database
sl@0	1114	** ----------------- -------------- ------------------------------
sl@0	1115	** 0 any file
sl@0	1116	** 1 1 file
sl@0	1117	** 1 2 memory
sl@0	1118	** 1 0 file
sl@0	1119	** 2 1 file
sl@0	1120	** 2 2 memory
sl@0	1121	** 2 0 memory
sl@0	1122	** 3 any memory
sl@0	1123	*/
sl@0	1124	int sqlite3BtreeFactory(
sl@0	1125	const sqlite3 db, / Main database when opening aux otherwise 0 */
sl@0	1126	const char zFilename, / Name of the file containing the BTree database */
sl@0	1127	int omitJournal, /* if TRUE then do not journal this file */
sl@0	1128	int nCache, /* How many pages in the page cache */
sl@0	1129	int vfsFlags, /* Flags passed through to vfsOpen */
sl@0	1130	Btree *ppBtree / Pointer to new Btree object written here */
sl@0	1131	){
sl@0	1132	int btFlags = 0;
sl@0	1133	int rc;
sl@0	1134
sl@0	1135	assert( sqlite3_mutex_held(db->mutex) );
sl@0	1136	assert( ppBtree != 0);
sl@0	1137	if( omitJournal ){
sl@0	1138	btFlags \|= BTREE_OMIT_JOURNAL;
sl@0	1139	}
sl@0	1140	if( db->flags & SQLITE_NoReadlock ){
sl@0	1141	btFlags \|= BTREE_NO_READLOCK;
sl@0	1142	}
sl@0	1143	if( zFilename==0 ){
sl@0	1144	#if SQLITE_TEMP_STORE==0
sl@0	1145	/* Do nothing */
sl@0	1146	#endif
sl@0	1147	#ifndef SQLITE_OMIT_MEMORYDB
sl@0	1148	#if SQLITE_TEMP_STORE==1
sl@0	1149	if( db->temp_store==2 ) zFilename = ":memory:";
sl@0	1150	#endif
sl@0	1151	#if SQLITE_TEMP_STORE==2
sl@0	1152	if( db->temp_store!=1 ) zFilename = ":memory:";
sl@0	1153	#endif
sl@0	1154	#if SQLITE_TEMP_STORE==3
sl@0	1155	zFilename = ":memory:";
sl@0	1156	#endif
sl@0	1157	#endif /* SQLITE_OMIT_MEMORYDB */
sl@0	1158	}
sl@0	1159
sl@0	1160	if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (zFilename==0 \|\| *zFilename==0) ){
sl@0	1161	vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) \| SQLITE_OPEN_TEMP_DB;
sl@0	1162	}
sl@0	1163	rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btFlags, vfsFlags);
sl@0	1164
sl@0	1165	/* If the B-Tree was successfully opened, set the pager-cache size to the
sl@0	1166	** default value. Except, if the call to BtreeOpen() returned a handle
sl@0	1167	** open on an existing shared pager-cache, do not change the pager-cache
sl@0	1168	** size.
sl@0	1169	*/
sl@0	1170	if( rc==SQLITE_OK && 0==sqlite3BtreeSchema(*ppBtree, 0, 0) ){
sl@0	1171	sqlite3BtreeSetCacheSize(*ppBtree, nCache);
sl@0	1172	}
sl@0	1173	return rc;
sl@0	1174	}
sl@0	1175
sl@0	1176	/*
sl@0	1177	** Return UTF-8 encoded English language explanation of the most recent
sl@0	1178	** error.
sl@0	1179	*/
sl@0	1180	SQLITE_EXPORT const char sqlite3_errmsg(sqlite3 db){
sl@0	1181	const char *z;
sl@0	1182	if( !db ){
sl@0	1183	return sqlite3ErrStr(SQLITE_NOMEM);
sl@0	1184	}
sl@0	1185	if( !sqlite3SafetyCheckSickOrOk(db) ){
sl@0	1186	return sqlite3ErrStr(SQLITE_MISUSE);
sl@0	1187	}
sl@0	1188	sqlite3_mutex_enter(db->mutex);
sl@0	1189	assert( !db->mallocFailed );
sl@0	1190	z = (char*)sqlite3_value_text(db->pErr);
sl@0	1191	assert( !db->mallocFailed );
sl@0	1192	if( z==0 ){
sl@0	1193	z = sqlite3ErrStr(db->errCode);
sl@0	1194	}
sl@0	1195	sqlite3_mutex_leave(db->mutex);
sl@0	1196	return z;
sl@0	1197	}
sl@0	1198
sl@0	1199	#ifndef SQLITE_OMIT_UTF16
sl@0	1200	/*
sl@0	1201	** Return UTF-16 encoded English language explanation of the most recent
sl@0	1202	** error.
sl@0	1203	*/
sl@0	1204	SQLITE_EXPORT const void sqlite3_errmsg16(sqlite3 db){
sl@0	1205	/* Because all the characters in the string are in the unicode
sl@0	1206	** range 0x00-0xFF, if we pad the big-endian string with a
sl@0	1207	** zero byte, we can obtain the little-endian string with
sl@0	1208	** &big_endian[1].
sl@0	1209	*/
sl@0	1210	static const char outOfMemBe[] = {
sl@0	1211	0, 'o', 0, 'u', 0, 't', 0, ' ',
sl@0	1212	0, 'o', 0, 'f', 0, ' ',
sl@0	1213	0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0
sl@0	1214	};
sl@0	1215	static const char misuseBe [] = {
sl@0	1216	0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ',
sl@0	1217	0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ',
sl@0	1218	0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ',
sl@0	1219	0, 'o', 0, 'u', 0, 't', 0, ' ',
sl@0	1220	0, 'o', 0, 'f', 0, ' ',
sl@0	1221	0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0
sl@0	1222	};
sl@0	1223
sl@0	1224	const void *z;
sl@0	1225	if( !db ){
sl@0	1226	return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
sl@0	1227	}
sl@0	1228	if( !sqlite3SafetyCheckSickOrOk(db) ){
sl@0	1229	return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
sl@0	1230	}
sl@0	1231	sqlite3_mutex_enter(db->mutex);
sl@0	1232	assert( !db->mallocFailed );
sl@0	1233	z = sqlite3_value_text16(db->pErr);
sl@0	1234	if( z==0 ){
sl@0	1235	sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
sl@0	1236	SQLITE_UTF8, SQLITE_STATIC);
sl@0	1237	z = sqlite3_value_text16(db->pErr);
sl@0	1238	}
sl@0	1239	/* A malloc() may have failed within the call to sqlite3_value_text16()
sl@0	1240	** above. If this is the case, then the db->mallocFailed flag needs to
sl@0	1241	** be cleared before returning. Do this directly, instead of via
sl@0	1242	** sqlite3ApiExit(), to avoid setting the database handle error message.
sl@0	1243	*/
sl@0	1244	db->mallocFailed = 0;
sl@0	1245	sqlite3_mutex_leave(db->mutex);
sl@0	1246	return z;
sl@0	1247	}
sl@0	1248	#endif /* SQLITE_OMIT_UTF16 */
sl@0	1249
sl@0	1250	/*
sl@0	1251	** Return the most recent error code generated by an SQLite routine. If NULL is
sl@0	1252	** passed to this function, we assume a malloc() failed during sqlite3_open().
sl@0	1253	*/
sl@0	1254	SQLITE_EXPORT int sqlite3_errcode(sqlite3 *db){
sl@0	1255	if( db && !sqlite3SafetyCheckSickOrOk(db) ){
sl@0	1256	return SQLITE_MISUSE;
sl@0	1257	}
sl@0	1258	if( !db \|\| db->mallocFailed ){
sl@0	1259	return SQLITE_NOMEM;
sl@0	1260	}
sl@0	1261	return db->errCode & db->errMask;
sl@0	1262	}
sl@0	1263
sl@0	1264	/*
sl@0	1265	** Create a new collating function for database "db". The name is zName
sl@0	1266	** and the encoding is enc.
sl@0	1267	*/
sl@0	1268	static int createCollation(
sl@0	1269	sqlite3* db,
sl@0	1270	const char *zName,
sl@0	1271	int enc,
sl@0	1272	void* pCtx,
sl@0	1273	int(xCompare)(void,int,const void,int,const void),
sl@0	1274	void(xDel)(void)
sl@0	1275	){
sl@0	1276	CollSeq *pColl;
sl@0	1277	int enc2;
sl@0	1278	int nName;
sl@0	1279
sl@0	1280	assert( sqlite3_mutex_held(db->mutex) );
sl@0	1281
sl@0	1282	/* If SQLITE_UTF16 is specified as the encoding type, transform this
sl@0	1283	** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
sl@0	1284	** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
sl@0	1285	*/
sl@0	1286	enc2 = enc & ~SQLITE_UTF16_ALIGNED;
sl@0	1287	if( enc2==SQLITE_UTF16 ){
sl@0	1288	enc2 = SQLITE_UTF16NATIVE;
sl@0	1289	}
sl@0	1290	if( (enc2&~3)!=0 ){
sl@0	1291	return SQLITE_MISUSE;
sl@0	1292	}
sl@0	1293
sl@0	1294	/* Check if this call is removing or replacing an existing collation
sl@0	1295	** sequence. If so, and there are active VMs, return busy. If there
sl@0	1296	** are no active VMs, invalidate any pre-compiled statements.
sl@0	1297	*/
sl@0	1298	nName = sqlite3Strlen(db, zName);
sl@0	1299	pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, nName, 0);
sl@0	1300	if( pColl && pColl->xCmp ){
sl@0	1301	if( db->activeVdbeCnt ){
sl@0	1302	sqlite3Error(db, SQLITE_BUSY,
sl@0	1303	"Unable to delete/modify collation sequence due to active statements");
sl@0	1304	return SQLITE_BUSY;
sl@0	1305	}
sl@0	1306	sqlite3ExpirePreparedStatements(db);
sl@0	1307
sl@0	1308	/* If collation sequence pColl was created directly by a call to
sl@0	1309	** sqlite3_create_collation, and not generated by synthCollSeq(),
sl@0	1310	** then any copies made by synthCollSeq() need to be invalidated.
sl@0	1311	** Also, collation destructor - CollSeq.xDel() - function may need
sl@0	1312	** to be called.
sl@0	1313	*/
sl@0	1314	if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
sl@0	1315	CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
sl@0	1316	int j;
sl@0	1317	for(j=0; j<3; j++){
sl@0	1318	CollSeq *p = &aColl[j];
sl@0	1319	if( p->enc==pColl->enc ){
sl@0	1320	if( p->xDel ){
sl@0	1321	p->xDel(p->pUser);
sl@0	1322	}
sl@0	1323	p->xCmp = 0;
sl@0	1324	}
sl@0	1325	}
sl@0	1326	}
sl@0	1327	}
sl@0	1328
sl@0	1329	pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, nName, 1);
sl@0	1330	if( pColl ){
sl@0	1331	pColl->xCmp = xCompare;
sl@0	1332	pColl->pUser = pCtx;
sl@0	1333	pColl->xDel = xDel;
sl@0	1334	pColl->enc = enc2 \| (enc & SQLITE_UTF16_ALIGNED);
sl@0	1335	}
sl@0	1336	sqlite3Error(db, SQLITE_OK, 0);
sl@0	1337	return SQLITE_OK;
sl@0	1338	}
sl@0	1339
sl@0	1340
sl@0	1341	/*
sl@0	1342	** This array defines hard upper bounds on limit values. The
sl@0	1343	** initializer must be kept in sync with the SQLITE_LIMIT_*
sl@0	1344	** #defines in sqlite3.h.
sl@0	1345	*/
sl@0	1346	static const int aHardLimit[] = {
sl@0	1347	SQLITE_MAX_LENGTH,
sl@0	1348	SQLITE_MAX_SQL_LENGTH,
sl@0	1349	SQLITE_MAX_COLUMN,
sl@0	1350	SQLITE_MAX_EXPR_DEPTH,
sl@0	1351	SQLITE_MAX_COMPOUND_SELECT,
sl@0	1352	SQLITE_MAX_VDBE_OP,
sl@0	1353	SQLITE_MAX_FUNCTION_ARG,
sl@0	1354	SQLITE_MAX_ATTACHED,
sl@0	1355	SQLITE_MAX_LIKE_PATTERN_LENGTH,
sl@0	1356	SQLITE_MAX_VARIABLE_NUMBER,
sl@0	1357	};
sl@0	1358
sl@0	1359	/*
sl@0	1360	** Make sure the hard limits are set to reasonable values
sl@0	1361	*/
sl@0	1362	#if SQLITE_MAX_LENGTH<100
sl@0	1363	# error SQLITE_MAX_LENGTH must be at least 100
sl@0	1364	#endif
sl@0	1365	#if SQLITE_MAX_SQL_LENGTH<100
sl@0	1366	# error SQLITE_MAX_SQL_LENGTH must be at least 100
sl@0	1367	#endif
sl@0	1368	#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
sl@0	1369	# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
sl@0	1370	#endif
sl@0	1371	#if SQLITE_MAX_COMPOUND_SELECT<2
sl@0	1372	# error SQLITE_MAX_COMPOUND_SELECT must be at least 2
sl@0	1373	#endif
sl@0	1374	#if SQLITE_MAX_VDBE_OP<40
sl@0	1375	# error SQLITE_MAX_VDBE_OP must be at least 40
sl@0	1376	#endif
sl@0	1377	#if SQLITE_MAX_FUNCTION_ARG<0 \|\| SQLITE_MAX_FUNCTION_ARG>127
sl@0	1378	# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127
sl@0	1379	#endif
sl@0	1380	#if SQLITE_MAX_ATTACHED<0 \|\| SQLITE_MAX_ATTACHED>30
sl@0	1381	# error SQLITE_MAX_ATTACHED must be between 0 and 30
sl@0	1382	#endif
sl@0	1383	#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
sl@0	1384	# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
sl@0	1385	#endif
sl@0	1386	#if SQLITE_MAX_VARIABLE_NUMBER<1
sl@0	1387	# error SQLITE_MAX_VARIABLE_NUMBER must be at least 1
sl@0	1388	#endif
sl@0	1389	#if SQLITE_MAX_COLUMN>32767
sl@0	1390	# error SQLITE_MAX_COLUMN must not exceed 32767
sl@0	1391	#endif
sl@0	1392
sl@0	1393
sl@0	1394	/*
sl@0	1395	** Change the value of a limit. Report the old value.
sl@0	1396	** If an invalid limit index is supplied, report -1.
sl@0	1397	** Make no changes but still report the old value if the
sl@0	1398	** new limit is negative.
sl@0	1399	**
sl@0	1400	** A new lower limit does not shrink existing constructs.
sl@0	1401	** It merely prevents new constructs that exceed the limit
sl@0	1402	** from forming.
sl@0	1403	*/
sl@0	1404	SQLITE_EXPORT int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
sl@0	1405	int oldLimit;
sl@0	1406	if( limitId<0 \|\| limitId>=SQLITE_N_LIMIT ){
sl@0	1407	return -1;
sl@0	1408	}
sl@0	1409	oldLimit = db->aLimit[limitId];
sl@0	1410	if( newLimit>=0 ){
sl@0	1411	if( newLimit>aHardLimit[limitId] ){
sl@0	1412	newLimit = aHardLimit[limitId];
sl@0	1413	}
sl@0	1414	db->aLimit[limitId] = newLimit;
sl@0	1415	}
sl@0	1416	return oldLimit;
sl@0	1417	}
sl@0	1418
sl@0	1419	/*
sl@0	1420	** This routine does the work of opening a database on behalf of
sl@0	1421	** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
sl@0	1422	** is UTF-8 encoded.
sl@0	1423	*/
sl@0	1424	static int openDatabase(
sl@0	1425	const char zFilename, / Database filename UTF-8 encoded */
sl@0	1426	sqlite3 *ppDb, / OUT: Returned database handle */
sl@0	1427	unsigned flags, /* Operational flags */
sl@0	1428	const char zVfs / Name of the VFS to use */
sl@0	1429	){
sl@0	1430	sqlite3 *db;
sl@0	1431	int rc;
sl@0	1432	CollSeq *pColl;
sl@0	1433	int isThreadsafe;
sl@0	1434
sl@0	1435	#ifndef SQLITE_OMIT_AUTOINIT
sl@0	1436	rc = sqlite3_initialize();
sl@0	1437	if( rc ) return rc;
sl@0	1438	#endif
sl@0	1439
sl@0	1440	if( sqlite3GlobalConfig.bCoreMutex==0 ){
sl@0	1441	isThreadsafe = 0;
sl@0	1442	}else if( flags & SQLITE_OPEN_NOMUTEX ){
sl@0	1443	isThreadsafe = 0;
sl@0	1444	}else if( flags & SQLITE_OPEN_FULLMUTEX ){
sl@0	1445	isThreadsafe = 1;
sl@0	1446	}else{
sl@0	1447	isThreadsafe = sqlite3GlobalConfig.bFullMutex;
sl@0	1448	}
sl@0	1449
sl@0	1450	/* Remove harmful bits from the flags parameter */
sl@0	1451	flags &= ~( SQLITE_OPEN_DELETEONCLOSE \|
sl@0	1452	SQLITE_OPEN_MAIN_DB \|
sl@0	1453	SQLITE_OPEN_TEMP_DB \|
sl@0	1454	SQLITE_OPEN_TRANSIENT_DB \|
sl@0	1455	SQLITE_OPEN_MAIN_JOURNAL \|
sl@0	1456	SQLITE_OPEN_TEMP_JOURNAL \|
sl@0	1457	SQLITE_OPEN_SUBJOURNAL \|
sl@0	1458	SQLITE_OPEN_MASTER_JOURNAL \|
sl@0	1459	SQLITE_OPEN_NOMUTEX \|
sl@0	1460	SQLITE_OPEN_FULLMUTEX
sl@0	1461	);
sl@0	1462
sl@0	1463	/* Allocate the sqlite data structure */
sl@0	1464	db = sqlite3MallocZero( sizeof(sqlite3) );
sl@0	1465	if( db==0 ) goto opendb_out;
sl@0	1466	if( isThreadsafe ){
sl@0	1467	db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
sl@0	1468	if( db->mutex==0 ){
sl@0	1469	sqlite3_free(db);
sl@0	1470	db = 0;
sl@0	1471	goto opendb_out;
sl@0	1472	}
sl@0	1473	}
sl@0	1474	sqlite3_mutex_enter(db->mutex);
sl@0	1475	db->errMask = 0xff;
sl@0	1476	db->priorNewRowid = 0;
sl@0	1477	db->nDb = 2;
sl@0	1478	db->magic = SQLITE_MAGIC_BUSY;
sl@0	1479	db->aDb = db->aDbStatic;
sl@0	1480
sl@0	1481	assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
sl@0	1482	memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
sl@0	1483	db->autoCommit = 1;
sl@0	1484	db->nextAutovac = -1;
sl@0	1485	db->nextPagesize = 0;
sl@0	1486	db->flags \|= SQLITE_ShortColNames
sl@0	1487	#if SQLITE_DEFAULT_FILE_FORMAT<4
sl@0	1488	\| SQLITE_LegacyFileFmt
sl@0	1489	#endif
sl@0	1490	#ifdef SQLITE_ENABLE_LOAD_EXTENSION
sl@0	1491	\| SQLITE_LoadExtension
sl@0	1492	#endif
sl@0	1493	;
sl@0	1494	sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);
sl@0	1495	#ifndef SQLITE_OMIT_VIRTUALTABLE
sl@0	1496	sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0);
sl@0	1497	#endif
sl@0	1498
sl@0	1499	db->pVfs = sqlite3_vfs_find(zVfs);
sl@0	1500	if( !db->pVfs ){
sl@0	1501	rc = SQLITE_ERROR;
sl@0	1502	sqlite3Error(db, rc, "no such vfs: %s", zVfs);
sl@0	1503	goto opendb_out;
sl@0	1504	}
sl@0	1505
sl@0	1506	/* Add the default collation sequence BINARY. BINARY works for both UTF-8
sl@0	1507	** and UTF-16, so add a version for each to avoid any unnecessary
sl@0	1508	** conversions. The only error that can occur here is a malloc() failure.
sl@0	1509	*/
sl@0	1510	createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
sl@0	1511	createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
sl@0	1512	createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
sl@0	1513	createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
sl@0	1514	if( db->mallocFailed ){
sl@0	1515	goto opendb_out;
sl@0	1516	}
sl@0	1517	db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
sl@0	1518	assert( db->pDfltColl!=0 );
sl@0	1519
sl@0	1520	/* Also add a UTF-8 case-insensitive collation sequence. */
sl@0	1521	createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
sl@0	1522
sl@0	1523	/* Set flags on the built-in collating sequences */
sl@0	1524	db->pDfltColl->type = SQLITE_COLL_BINARY;
sl@0	1525	pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);
sl@0	1526	if( pColl ){
sl@0	1527	pColl->type = SQLITE_COLL_NOCASE;
sl@0	1528	}
sl@0	1529
sl@0	1530	/* Open the backend database driver */
sl@0	1531	db->openFlags = flags;
sl@0	1532	rc = sqlite3BtreeFactory(db, zFilename, 0, SQLITE_DEFAULT_CACHE_SIZE,
sl@0	1533	flags \| SQLITE_OPEN_MAIN_DB,
sl@0	1534	&db->aDb[0].pBt);
sl@0	1535	if( rc!=SQLITE_OK ){
sl@0	1536	if( rc==SQLITE_IOERR_NOMEM ){
sl@0	1537	rc = SQLITE_NOMEM;
sl@0	1538	}
sl@0	1539	sqlite3Error(db, rc, 0);
sl@0	1540	goto opendb_out;
sl@0	1541	}
sl@0	1542	db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
sl@0	1543	db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
sl@0	1544
sl@0	1545
sl@0	1546	/* The default safety_level for the main database is 'full'; for the temp
sl@0	1547	** database it is 'NONE'. This matches the pager layer defaults.
sl@0	1548	*/
sl@0	1549	db->aDb[0].zName = "main";
sl@0	1550	db->aDb[0].safety_level = 3;
sl@0	1551	#ifndef SQLITE_OMIT_TEMPDB
sl@0	1552	db->aDb[1].zName = "temp";
sl@0	1553	db->aDb[1].safety_level = 1;
sl@0	1554	#endif
sl@0	1555
sl@0	1556	db->magic = SQLITE_MAGIC_OPEN;
sl@0	1557	if( db->mallocFailed ){
sl@0	1558	goto opendb_out;
sl@0	1559	}
sl@0	1560
sl@0	1561	/* Register all built-in functions, but do not attempt to read the
sl@0	1562	** database schema yet. This is delayed until the first time the database
sl@0	1563	** is accessed.
sl@0	1564	*/
sl@0	1565	sqlite3Error(db, SQLITE_OK, 0);
sl@0	1566	sqlite3RegisterBuiltinFunctions(db);
sl@0	1567
sl@0	1568	/* Load automatic extensions - extensions that have been registered
sl@0	1569	** using the sqlite3_automatic_extension() API.
sl@0	1570	*/
sl@0	1571	(void)sqlite3AutoLoadExtensions(db);
sl@0	1572	if( sqlite3_errcode(db)!=SQLITE_OK ){
sl@0	1573	goto opendb_out;
sl@0	1574	}
sl@0	1575
sl@0	1576	#ifdef SQLITE_ENABLE_FTS1
sl@0	1577	if( !db->mallocFailed ){
sl@0	1578	extern int sqlite3Fts1Init(sqlite3*);
sl@0	1579	rc = sqlite3Fts1Init(db);
sl@0	1580	}
sl@0	1581	#endif
sl@0	1582
sl@0	1583	#ifdef SQLITE_ENABLE_FTS2
sl@0	1584	if( !db->mallocFailed && rc==SQLITE_OK ){
sl@0	1585	extern int sqlite3Fts2Init(sqlite3*);
sl@0	1586	rc = sqlite3Fts2Init(db);
sl@0	1587	}
sl@0	1588	#endif
sl@0	1589
sl@0	1590	#ifdef SQLITE_ENABLE_FTS3
sl@0	1591	if( !db->mallocFailed && rc==SQLITE_OK ){
sl@0	1592	rc = sqlite3Fts3Init(db);
sl@0	1593	}
sl@0	1594	#endif
sl@0	1595
sl@0	1596	#ifdef SQLITE_ENABLE_ICU
sl@0	1597	if( !db->mallocFailed && rc==SQLITE_OK ){
sl@0	1598	rc = sqlite3IcuInit(db);
sl@0	1599	}
sl@0	1600	#endif
sl@0	1601
sl@0	1602	#ifdef SQLITE_ENABLE_RTREE
sl@0	1603	if( !db->mallocFailed && rc==SQLITE_OK){
sl@0	1604	rc = sqlite3RtreeInit(db);
sl@0	1605	}
sl@0	1606	#endif
sl@0	1607
sl@0	1608	sqlite3Error(db, rc, 0);
sl@0	1609
sl@0	1610	/* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
sl@0	1611	** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
sl@0	1612	** mode. Doing nothing at all also makes NORMAL the default.
sl@0	1613	*/
sl@0	1614	#ifdef SQLITE_DEFAULT_LOCKING_MODE
sl@0	1615	db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
sl@0	1616	sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
sl@0	1617	SQLITE_DEFAULT_LOCKING_MODE);
sl@0	1618	#endif
sl@0	1619
sl@0	1620	/* Enable the lookaside-malloc subsystem */
sl@0	1621	setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside, sqlite3GlobalConfig.nLookaside);
sl@0	1622
sl@0	1623	opendb_out:
sl@0	1624	if( db ){
sl@0	1625	assert( db->mutex!=0 \|\| isThreadsafe==0 \|\| sqlite3GlobalConfig.bFullMutex==0 );
sl@0	1626	sqlite3_mutex_leave(db->mutex);
sl@0	1627	}
sl@0	1628	rc = sqlite3_errcode(db);
sl@0	1629	if( rc==SQLITE_NOMEM ){
sl@0	1630	sqlite3_close(db);
sl@0	1631	db = 0;
sl@0	1632	}else if( rc!=SQLITE_OK ){
sl@0	1633	db->magic = SQLITE_MAGIC_SICK;
sl@0	1634	}
sl@0	1635	*ppDb = db;
sl@0	1636	return sqlite3ApiExit(0, rc);
sl@0	1637	}
sl@0	1638
sl@0	1639	/*
sl@0	1640	** Open a new database handle.
sl@0	1641	*/
sl@0	1642	SQLITE_EXPORT int sqlite3_open(
sl@0	1643	const char *zFilename,
sl@0	1644	sqlite3 **ppDb
sl@0	1645	){
sl@0	1646	return openDatabase(zFilename, ppDb,
sl@0	1647	SQLITE_OPEN_READWRITE \| SQLITE_OPEN_CREATE, 0);
sl@0	1648	}
sl@0	1649	SQLITE_EXPORT int sqlite3_open_v2(
sl@0	1650	const char filename, / Database filename (UTF-8) */
sl@0	1651	sqlite3 *ppDb, / OUT: SQLite db handle */
sl@0	1652	int flags, /* Flags */
sl@0	1653	const char zVfs / Name of VFS module to use */
sl@0	1654	){
sl@0	1655	return openDatabase(filename, ppDb, flags, zVfs);
sl@0	1656	}
sl@0	1657
sl@0	1658	#ifndef SQLITE_OMIT_UTF16
sl@0	1659	/*
sl@0	1660	** Open a new database handle.
sl@0	1661	*/
sl@0	1662	SQLITE_EXPORT int sqlite3_open16(
sl@0	1663	const void *zFilename,
sl@0	1664	sqlite3 **ppDb
sl@0	1665	){
sl@0	1666	char const zFilename8; / zFilename encoded in UTF-8 instead of UTF-16 */
sl@0	1667	sqlite3_value *pVal;
sl@0	1668	int rc;
sl@0	1669
sl@0	1670	assert( zFilename );
sl@0	1671	assert( ppDb );
sl@0	1672	*ppDb = 0;
sl@0	1673	#ifndef SQLITE_OMIT_AUTOINIT
sl@0	1674	rc = sqlite3_initialize();
sl@0	1675	if( rc ) return rc;
sl@0	1676	#endif
sl@0	1677	pVal = sqlite3ValueNew(0);
sl@0	1678	sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
sl@0	1679	zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
sl@0	1680	if( zFilename8 ){
sl@0	1681	rc = openDatabase(zFilename8, ppDb,
sl@0	1682	SQLITE_OPEN_READWRITE \| SQLITE_OPEN_CREATE, 0);
sl@0	1683	assert( *ppDb \|\| rc==SQLITE_NOMEM );
sl@0	1684	if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
sl@0	1685	ENC(*ppDb) = SQLITE_UTF16NATIVE;
sl@0	1686	}
sl@0	1687	}else{
sl@0	1688	rc = SQLITE_NOMEM;
sl@0	1689	}
sl@0	1690	sqlite3ValueFree(pVal);
sl@0	1691
sl@0	1692	return sqlite3ApiExit(0, rc);
sl@0	1693	}
sl@0	1694	#endif /* SQLITE_OMIT_UTF16 */
sl@0	1695
sl@0	1696	/*
sl@0	1697	** Register a new collation sequence with the database handle db.
sl@0	1698	*/
sl@0	1699	SQLITE_EXPORT int sqlite3_create_collation(
sl@0	1700	sqlite3* db,
sl@0	1701	const char *zName,
sl@0	1702	int enc,
sl@0	1703	void* pCtx,
sl@0	1704	int(xCompare)(void,int,const void,int,const void)
sl@0	1705	){
sl@0	1706	int rc;
sl@0	1707	sqlite3_mutex_enter(db->mutex);
sl@0	1708	assert( !db->mallocFailed );
sl@0	1709	rc = createCollation(db, zName, enc, pCtx, xCompare, 0);
sl@0	1710	rc = sqlite3ApiExit(db, rc);
sl@0	1711	sqlite3_mutex_leave(db->mutex);
sl@0	1712	return rc;
sl@0	1713	}
sl@0	1714
sl@0	1715	/*
sl@0	1716	** Register a new collation sequence with the database handle db.
sl@0	1717	*/
sl@0	1718	SQLITE_EXPORT int sqlite3_create_collation_v2(
sl@0	1719	sqlite3* db,
sl@0	1720	const char *zName,
sl@0	1721	int enc,
sl@0	1722	void* pCtx,
sl@0	1723	int(xCompare)(void,int,const void,int,const void),
sl@0	1724	void(xDel)(void)
sl@0	1725	){
sl@0	1726	int rc;
sl@0	1727	sqlite3_mutex_enter(db->mutex);
sl@0	1728	assert( !db->mallocFailed );
sl@0	1729	rc = createCollation(db, zName, enc, pCtx, xCompare, xDel);
sl@0	1730	rc = sqlite3ApiExit(db, rc);
sl@0	1731	sqlite3_mutex_leave(db->mutex);
sl@0	1732	return rc;
sl@0	1733	}
sl@0	1734
sl@0	1735	#ifndef SQLITE_OMIT_UTF16
sl@0	1736	/*
sl@0	1737	** Register a new collation sequence with the database handle db.
sl@0	1738	*/
sl@0	1739	SQLITE_EXPORT int sqlite3_create_collation16(
sl@0	1740	sqlite3* db,
sl@0	1741	const void *zName,
sl@0	1742	int enc,
sl@0	1743	void* pCtx,
sl@0	1744	int(xCompare)(void,int,const void,int,const void)
sl@0	1745	){
sl@0	1746	int rc = SQLITE_OK;
sl@0	1747	char *zName8;
sl@0	1748	sqlite3_mutex_enter(db->mutex);
sl@0	1749	assert( !db->mallocFailed );
sl@0	1750	zName8 = sqlite3Utf16to8(db, zName, -1);
sl@0	1751	if( zName8 ){
sl@0	1752	rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
sl@0	1753	sqlite3DbFree(db, zName8);
sl@0	1754	}
sl@0	1755	rc = sqlite3ApiExit(db, rc);
sl@0	1756	sqlite3_mutex_leave(db->mutex);
sl@0	1757	return rc;
sl@0	1758	}
sl@0	1759	#endif /* SQLITE_OMIT_UTF16 */
sl@0	1760
sl@0	1761	/*
sl@0	1762	** Register a collation sequence factory callback with the database handle
sl@0	1763	** db. Replace any previously installed collation sequence factory.
sl@0	1764	*/
sl@0	1765	SQLITE_EXPORT int sqlite3_collation_needed(
sl@0	1766	sqlite3 *db,
sl@0	1767	void *pCollNeededArg,
sl@0	1768	void(xCollNeeded)(void,sqlite3,int eTextRep,const char)
sl@0	1769	){
sl@0	1770	sqlite3_mutex_enter(db->mutex);
sl@0	1771	db->xCollNeeded = xCollNeeded;
sl@0	1772	db->xCollNeeded16 = 0;
sl@0	1773	db->pCollNeededArg = pCollNeededArg;
sl@0	1774	sqlite3_mutex_leave(db->mutex);
sl@0	1775	return SQLITE_OK;
sl@0	1776	}
sl@0	1777
sl@0	1778	#ifndef SQLITE_OMIT_UTF16
sl@0	1779	/*
sl@0	1780	** Register a collation sequence factory callback with the database handle
sl@0	1781	** db. Replace any previously installed collation sequence factory.
sl@0	1782	*/
sl@0	1783	SQLITE_EXPORT int sqlite3_collation_needed16(
sl@0	1784	sqlite3 *db,
sl@0	1785	void *pCollNeededArg,
sl@0	1786	void(xCollNeeded16)(void,sqlite3,int eTextRep,const void)
sl@0	1787	){
sl@0	1788	sqlite3_mutex_enter(db->mutex);
sl@0	1789	db->xCollNeeded = 0;
sl@0	1790	db->xCollNeeded16 = xCollNeeded16;
sl@0	1791	db->pCollNeededArg = pCollNeededArg;
sl@0	1792	sqlite3_mutex_leave(db->mutex);
sl@0	1793	return SQLITE_OK;
sl@0	1794	}
sl@0	1795	#endif /* SQLITE_OMIT_UTF16 */
sl@0	1796
sl@0	1797	#ifndef SQLITE_OMIT_GLOBALRECOVER
sl@0	1798	/*
sl@0	1799	** This function is now an anachronism. It used to be used to recover from a
sl@0	1800	** malloc() failure, but SQLite now does this automatically.
sl@0	1801	*/
sl@0	1802	SQLITE_EXPORT int sqlite3_global_recover(void){
sl@0	1803	return SQLITE_OK;
sl@0	1804	}
sl@0	1805	#endif
sl@0	1806
sl@0	1807	/*
sl@0	1808	** Test to see whether or not the database connection is in autocommit
sl@0	1809	** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
sl@0	1810	** by default. Autocommit is disabled by a BEGIN statement and reenabled
sl@0	1811	** by the next COMMIT or ROLLBACK.
sl@0	1812	**
sl@0	1813	***** THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****
sl@0	1814	*/
sl@0	1815	SQLITE_EXPORT int sqlite3_get_autocommit(sqlite3 *db){
sl@0	1816	return db->autoCommit;
sl@0	1817	}
sl@0	1818
sl@0	1819	#ifdef SQLITE_DEBUG
sl@0	1820	/*
sl@0	1821	** The following routine is subtituted for constant SQLITE_CORRUPT in
sl@0	1822	** debugging builds. This provides a way to set a breakpoint for when
sl@0	1823	** corruption is first detected.
sl@0	1824	*/
sl@0	1825	int sqlite3Corrupt(void){
sl@0	1826	return SQLITE_CORRUPT;
sl@0	1827	}
sl@0	1828	#endif
sl@0	1829
sl@0	1830	/*
sl@0	1831	** This is a convenience routine that makes sure that all thread-specific
sl@0	1832	** data for this thread has been deallocated.
sl@0	1833	**
sl@0	1834	** SQLite no longer uses thread-specific data so this routine is now a
sl@0	1835	** no-op. It is retained for historical compatibility.
sl@0	1836	*/
sl@0	1837	SQLITE_EXPORT void sqlite3_thread_cleanup(void){
sl@0	1838	}
sl@0	1839
sl@0	1840	/*
sl@0	1841	** Return meta information about a specific column of a database table.
sl@0	1842	** See comment in sqlite3.h (sqlite.h.in) for details.
sl@0	1843	*/
sl@0	1844	#ifdef SQLITE_ENABLE_COLUMN_METADATA
sl@0	1845	int sqlite3_table_column_metadata(
sl@0	1846	sqlite3 db, / Connection handle */
sl@0	1847	const char zDbName, / Database name or NULL */
sl@0	1848	const char zTableName, / Table name */
sl@0	1849	const char zColumnName, / Column name */
sl@0	1850	char const *pzDataType, / OUTPUT: Declared data type */
sl@0	1851	char const *pzCollSeq, / OUTPUT: Collation sequence name */
sl@0	1852	int pNotNull, / OUTPUT: True if NOT NULL constraint exists */
sl@0	1853	int pPrimaryKey, / OUTPUT: True if column part of PK */
sl@0	1854	int pAutoinc / OUTPUT: True if column is auto-increment */
sl@0	1855	){
sl@0	1856	int rc;
sl@0	1857	char *zErrMsg = 0;
sl@0	1858	Table *pTab = 0;
sl@0	1859	Column *pCol = 0;
sl@0	1860	int iCol;
sl@0	1861
sl@0	1862	char const *zDataType = 0;
sl@0	1863	char const *zCollSeq = 0;
sl@0	1864	int notnull = 0;
sl@0	1865	int primarykey = 0;
sl@0	1866	int autoinc = 0;
sl@0	1867
sl@0	1868	/* Ensure the database schema has been loaded */
sl@0	1869	sqlite3_mutex_enter(db->mutex);
sl@0	1870	(void)sqlite3SafetyOn(db);
sl@0	1871	sqlite3BtreeEnterAll(db);
sl@0	1872	rc = sqlite3Init(db, &zErrMsg);
sl@0	1873	sqlite3BtreeLeaveAll(db);
sl@0	1874	if( SQLITE_OK!=rc ){
sl@0	1875	goto error_out;
sl@0	1876	}
sl@0	1877
sl@0	1878	/* Locate the table in question */
sl@0	1879	pTab = sqlite3FindTable(db, zTableName, zDbName);
sl@0	1880	if( !pTab \|\| pTab->pSelect ){
sl@0	1881	pTab = 0;
sl@0	1882	goto error_out;
sl@0	1883	}
sl@0	1884
sl@0	1885	/* Find the column for which info is requested */
sl@0	1886	if( sqlite3IsRowid(zColumnName) ){
sl@0	1887	iCol = pTab->iPKey;
sl@0	1888	if( iCol>=0 ){
sl@0	1889	pCol = &pTab->aCol[iCol];
sl@0	1890	}
sl@0	1891	}else{
sl@0	1892	for(iCol=0; iCol<pTab->nCol; iCol++){
sl@0	1893	pCol = &pTab->aCol[iCol];
sl@0	1894	if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
sl@0	1895	break;
sl@0	1896	}
sl@0	1897	}
sl@0	1898	if( iCol==pTab->nCol ){
sl@0	1899	pTab = 0;
sl@0	1900	goto error_out;
sl@0	1901	}
sl@0	1902	}
sl@0	1903
sl@0	1904	/* The following block stores the meta information that will be returned
sl@0	1905	** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
sl@0	1906	** and autoinc. At this point there are two possibilities:
sl@0	1907	**
sl@0	1908	** 1. The specified column name was rowid", "oid" or "_rowid_"
sl@0	1909	** and there is no explicitly declared IPK column.
sl@0	1910	**
sl@0	1911	** 2. The table is not a view and the column name identified an
sl@0	1912	** explicitly declared column. Copy meta information from *pCol.
sl@0	1913	*/
sl@0	1914	if( pCol ){
sl@0	1915	zDataType = pCol->zType;
sl@0	1916	zCollSeq = pCol->zColl;
sl@0	1917	notnull = pCol->notNull!=0;
sl@0	1918	primarykey = pCol->isPrimKey!=0;
sl@0	1919	autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
sl@0	1920	}else{
sl@0	1921	zDataType = "INTEGER";
sl@0	1922	primarykey = 1;
sl@0	1923	}
sl@0	1924	if( !zCollSeq ){
sl@0	1925	zCollSeq = "BINARY";
sl@0	1926	}
sl@0	1927
sl@0	1928	error_out:
sl@0	1929	(void)sqlite3SafetyOff(db);
sl@0	1930
sl@0	1931	/* Whether the function call succeeded or failed, set the output parameters
sl@0	1932	** to whatever their local counterparts contain. If an error did occur,
sl@0	1933	** this has the effect of zeroing all output parameters.
sl@0	1934	*/
sl@0	1935	if( pzDataType ) *pzDataType = zDataType;
sl@0	1936	if( pzCollSeq ) *pzCollSeq = zCollSeq;
sl@0	1937	if( pNotNull ) *pNotNull = notnull;
sl@0	1938	if( pPrimaryKey ) *pPrimaryKey = primarykey;
sl@0	1939	if( pAutoinc ) *pAutoinc = autoinc;
sl@0	1940
sl@0	1941	if( SQLITE_OK==rc && !pTab ){
sl@0	1942	sqlite3DbFree(db, zErrMsg);
sl@0	1943	zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
sl@0	1944	zColumnName);
sl@0	1945	rc = SQLITE_ERROR;
sl@0	1946	}
sl@0	1947	sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
sl@0	1948	sqlite3DbFree(db, zErrMsg);
sl@0	1949	rc = sqlite3ApiExit(db, rc);
sl@0	1950	sqlite3_mutex_leave(db->mutex);
sl@0	1951	return rc;
sl@0	1952	}
sl@0	1953	#endif
sl@0	1954
sl@0	1955	/*
sl@0	1956	** Sleep for a little while. Return the amount of time slept.
sl@0	1957	*/
sl@0	1958	SQLITE_EXPORT int sqlite3_sleep(int ms){
sl@0	1959	sqlite3_vfs *pVfs;
sl@0	1960	int rc;
sl@0	1961	pVfs = sqlite3_vfs_find(0);
sl@0	1962	if( pVfs==0 ) return 0;
sl@0	1963
sl@0	1964	/* This function works in milliseconds, but the underlying OsSleep()
sl@0	1965	** API uses microseconds. Hence the 1000's.
sl@0	1966	*/
sl@0	1967	rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
sl@0	1968	return rc;
sl@0	1969	}
sl@0	1970
sl@0	1971	/*
sl@0	1972	** Enable or disable the extended result codes.
sl@0	1973	*/
sl@0	1974	SQLITE_EXPORT int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
sl@0	1975	sqlite3_mutex_enter(db->mutex);
sl@0	1976	db->errMask = onoff ? 0xffffffff : 0xff;
sl@0	1977	sqlite3_mutex_leave(db->mutex);
sl@0	1978	return SQLITE_OK;
sl@0	1979	}
sl@0	1980
sl@0	1981	/*
sl@0	1982	** Invoke the xFileControl method on a particular database.
sl@0	1983	*/
sl@0	1984	SQLITE_EXPORT int sqlite3_file_control(sqlite3 db, const char zDbName, int op, void *pArg){
sl@0	1985	int rc = SQLITE_ERROR;
sl@0	1986	int iDb;
sl@0	1987	sqlite3_mutex_enter(db->mutex);
sl@0	1988	if( zDbName==0 ){
sl@0	1989	iDb = 0;
sl@0	1990	}else{
sl@0	1991	for(iDb=0; iDb<db->nDb; iDb++){
sl@0	1992	if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
sl@0	1993	}
sl@0	1994	}
sl@0	1995	if( iDb<db->nDb ){
sl@0	1996	Btree *pBtree = db->aDb[iDb].pBt;
sl@0	1997	if( pBtree ){
sl@0	1998	Pager *pPager;
sl@0	1999	sqlite3_file *fd;
sl@0	2000	sqlite3BtreeEnter(pBtree);
sl@0	2001	pPager = sqlite3BtreePager(pBtree);
sl@0	2002	assert( pPager!=0 );
sl@0	2003	fd = sqlite3PagerFile(pPager);
sl@0	2004	assert( fd!=0 );
sl@0	2005	if( fd->pMethods ){
sl@0	2006	rc = sqlite3OsFileControl(fd, op, pArg);
sl@0	2007	}
sl@0	2008	sqlite3BtreeLeave(pBtree);
sl@0	2009	}
sl@0	2010	}
sl@0	2011	sqlite3_mutex_leave(db->mutex);
sl@0	2012	return rc;
sl@0	2013	}
sl@0	2014
sl@0	2015	/*
sl@0	2016	** Interface to the testing logic.
sl@0	2017	*/
sl@0	2018	SQLITE_EXPORT int sqlite3_test_control(int op, ...){
sl@0	2019	int rc = 0;
sl@0	2020	#ifndef SQLITE_OMIT_BUILTIN_TEST
sl@0	2021	va_list ap;
sl@0	2022	va_start(ap, op);
sl@0	2023	switch( op ){
sl@0	2024
sl@0	2025	/*
sl@0	2026	** Save the current state of the PRNG.
sl@0	2027	*/
sl@0	2028	case SQLITE_TESTCTRL_PRNG_SAVE: {
sl@0	2029	sqlite3PrngSaveState();
sl@0	2030	break;
sl@0	2031	}
sl@0	2032
sl@0	2033	/*
sl@0	2034	** Restore the state of the PRNG to the last state saved using
sl@0	2035	** PRNG_SAVE. If PRNG_SAVE has never before been called, then
sl@0	2036	** this verb acts like PRNG_RESET.
sl@0	2037	*/
sl@0	2038	case SQLITE_TESTCTRL_PRNG_RESTORE: {
sl@0	2039	sqlite3PrngRestoreState();
sl@0	2040	break;
sl@0	2041	}
sl@0	2042
sl@0	2043	/*
sl@0	2044	** Reset the PRNG back to its uninitialized state. The next call
sl@0	2045	** to sqlite3_randomness() will reseed the PRNG using a single call
sl@0	2046	** to the xRandomness method of the default VFS.
sl@0	2047	*/
sl@0	2048	case SQLITE_TESTCTRL_PRNG_RESET: {
sl@0	2049	sqlite3PrngResetState();
sl@0	2050	break;
sl@0	2051	}
sl@0	2052
sl@0	2053	/*
sl@0	2054	** sqlite3_test_control(BITVEC_TEST, size, program)
sl@0	2055	**
sl@0	2056	** Run a test against a Bitvec object of size. The program argument
sl@0	2057	** is an array of integers that defines the test. Return -1 on a
sl@0	2058	** memory allocation error, 0 on success, or non-zero for an error.
sl@0	2059	** See the sqlite3BitvecBuiltinTest() for additional information.
sl@0	2060	*/
sl@0	2061	case SQLITE_TESTCTRL_BITVEC_TEST: {
sl@0	2062	int sz = va_arg(ap, int);
sl@0	2063	int aProg = va_arg(ap, int);
sl@0	2064	rc = sqlite3BitvecBuiltinTest(sz, aProg);
sl@0	2065	break;
sl@0	2066	}
sl@0	2067
sl@0	2068	/*
sl@0	2069	** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
sl@0	2070	**
sl@0	2071	** Register hooks to call to indicate which malloc() failures
sl@0	2072	** are benign.
sl@0	2073	*/
sl@0	2074	case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
sl@0	2075	typedef void (*void_function)(void);
sl@0	2076	void_function xBenignBegin;
sl@0	2077	void_function xBenignEnd;
sl@0	2078	xBenignBegin = va_arg(ap, void_function);
sl@0	2079	xBenignEnd = va_arg(ap, void_function);
sl@0	2080	sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
sl@0	2081	break;
sl@0	2082	}
sl@0	2083	}
sl@0	2084	va_end(ap);
sl@0	2085	#endif /* SQLITE_OMIT_BUILTIN_TEST */
sl@0	2086	return rc;
sl@0	2087	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--