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

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