-C Fixes\sfor\sOMIT_SUBQUERY\sbuilds:\sDisable\swhere\sclause\sOR->IN\soptimization.\sInclude\sEXISTS\skeyword\s(for\snew\sCREATE\sTABLE\ssyntax).\sTest\sfile\sfixes.\s(CVS\s2943)
-D 2006-01-14T08:02:28
+C Documentation\supdates.\s\sFix\sto\sdate.c.\s\sBut\smost\simportantly:\sdatabase\nconnections\sare\snow\sallowed\sto\schange\sthreads\sas\slong\sas\sthey\sare\snot\nholding\sa\slock.\s(CVS\s2944)
+D 2006-01-15T00:13:16
F Makefile.in ab3ffd8d469cef4477257169b82810030a6bb967
F Makefile.linux-gcc aee18d8a05546dcf1888bd4547e442008a49a092
F README 9c4e2d6706bdcc3efdd773ce752a8cdab4f90028
F src/build.c 206c891028158668691f27bcbf7c3c4f15248a94
F src/callback.c ba3e6cc7a6beb562e7a66f92e26fabcb21aab1e2
F src/complete.c df1681cef40dec33a286006981845f87b194e7a4
-F src/date.c 5b86bc41754ffffb2b5742fbd71ea687f01cc6ca
+F src/date.c 5f5850c6b5da68fdc47d124573715ba948c9d8e0
F src/delete.c c7bd5708a629585e073ce34cf3b1fcb52c2fef38
F src/experimental.c 50c1e3b34f752f4ac10c36f287db095c2b61766d
F src/expr.c f885cfe73fb235635fba72e78bb858c64529771f
F src/os_common.h 6b76efa9b252e288de53b202ed5a0d48f48dc8db
F src/os_test.c 49833426101f99aee4bb5f6a44b7c4b2029fda1c
F src/os_test.h 903c93554c23d88f34f667f1979e4a1cee792af3
-F src/os_unix.c bc35a237a10c2ecb5c5b038d31d20ecb098dcc7d
+F src/os_unix.c e6ff5035b3d06fc69773e52e1bc6f7f7ccace084
F src/os_unix.h 5768d56d28240d3fe4537fac08cc85e4fb52279e
F src/os_win.c cd4ca2753aeaad11f5c9b9b6ef28752f45ed4529
F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b
F src/printf.c f47a2f4b5387cd2ebb12e9117a1a5d6bd9a2b812
F src/random.c d40f8d356cecbd351ccfab6eaedd7ec1b54f5261
F src/select.c 28d449c7762dd580aaba49a9c6c16e93ca951e49
-F src/server.c e425729aa7ff374637033a38ba9fd9938c432244
+F src/server.c 087b92a39d883e3fa113cae259d64e4c7438bc96
F src/shell.c 66b073375efbdee19045e7e0cd38b85f9aff71da
F src/sqlite.h.in 492580f7e3ff71eb43193eb7bb98e2d549889ce3
F src/sqliteInt.h ed482d6de58fa79000f9c3bb00d7740126fb55fb
F src/table.c 486dcfce532685b53b5a2b5da8bba0ded6fb2316
F src/tclsqlite.c d650bea0248fc0a310ddc2cb94273a3a5021fddf
-F src/test1.c 30ed0d4d594db0bb2beb98be7024cde1fe686f14
+F src/test1.c 22709543ac2f7a5979ec51c3130ba93cf6e82951
F src/test2.c ca74a1d8aeb7d9606e8f6b762c5daf85c1a3f92b
F src/test3.c 9742aa146eb750cab81c1d5605286c3a0eb88054
F src/test4.c 0f95de81629a53fc6ab104f64a7ccb1dcbb8af90
F test/select5.test 07a90ab3c7e3f0a241a9cdea1d997b2c8a89ff0b
F test/select6.test f459a19bdac0501c4d3eb1a4df4b7a76f1bb8ad4
F test/select7.test 1bf795b948c133a15a2a5e99d3270e652ec58ce6
-F test/server1.test 9d2d5b17b537911214a7e2a2728ff4f6ff16319c
+F test/server1.test e328b8e641ba8fe9273132cfef497383185dc1f5
F test/shared.test 2a7ae35bbf0f805cb9782146f5e812003ee8d1dc
F test/sort.test 0e4456e729e5a92a625907c63dcdedfbe72c5dc5
F test/subquery.test e6de53332c0301b3cfa34edc3f3cd5fa1e859efd
F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
F www/version3.tcl a99cf5f6d8bd4d5537584a2b342f0fb9fa601d8b
F www/whentouse.tcl 97e2b5cd296f7d8057e11f44427dea8a4c2db513
-P d634f8b28abd7af4565c644bd7972b067caa0133
-R e68269cdd28a8797bb4063cb46df0175
-U danielk1977
-Z 2134ba8d1976f430c91af4baa4a445ff
+P 8e79a0c24a03ccf960d6ccfb7c6b9b0f7c614e9b
+R 9d07ce30bc69528746c99ed3d4ba8921
+U drh
+Z 392783876068e8090d13d0e230d0bba8
-8e79a0c24a03ccf960d6ccfb7c6b9b0f7c614e9b
\ No newline at end of file
+03c422ecb508dd84dfafc8b7a0b790a43f5dadda
\ No newline at end of file
** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
** All other code has file scope.
**
-** $Id: date.c,v 1.50 2006/01/13 01:17:21 drh Exp $
+** $Id: date.c,v 1.51 2006/01/15 00:13:16 drh Exp $
**
** NOTES:
**
val = 0;
while( N-- ){
if( !isdigit(*(u8*)zDate) ){
- return cnt;
+ goto end_getDigits;
}
val = val*10 + *zDate - '0';
zDate++;
}
if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
- return cnt;
+ goto end_getDigits;
}
*pVal = val;
zDate++;
cnt++;
}while( nextC );
va_end(ap);
+end_getDigits:
return cnt;
}
** to another. This logic makes sure a user does not try to do that
** by mistake.
*/
-#if defined(SQLITE_UNIX_THREADS) && !defined(SQLITE_ALLOW_XTHREAD_CONNECTIONS)
+#if defined(SQLITE_UNIX_THREADS)
# define SET_THREADID(X) (X)->tid = pthread_self()
-# define CHECK_THREADID(X) (!pthread_equal((X)->tid, pthread_self()))
+# define CHECK_THREADID(X) (threadsOverrideEachOthersLocks==0 && \
+ !pthread_equal((X)->tid, pthread_self()))
#else
# define SET_THREADID(X)
# define CHECK_THREADID(X) 0
** 1: Yes. Threads can override each others locks.
** -1: We don't know yet.
*/
+#ifdef SQLITE_TEST
+int threadsOverrideEachOthersLocks = -1;
+#else
static int threadsOverrideEachOthersLocks = -1;
+#endif
/*
** This structure holds information passed into individual test
** Release a lockInfo structure previously allocated by findLockInfo().
*/
static void releaseLockInfo(struct lockInfo *pLock){
+ assert( sqlite3OsInMutex() );
pLock->nRef--;
if( pLock->nRef==0 ){
sqlite3HashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0);
** Release a openCnt structure previously allocated by findLockInfo().
*/
static void releaseOpenCnt(struct openCnt *pOpen){
+ assert( sqlite3OsInMutex() );
pOpen->nRef--;
if( pOpen->nRef==0 ){
sqlite3HashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0);
/*
** Given a file descriptor, locate lockInfo and openCnt structures that
-** describes that file descriptor. Create a new ones if necessary. The
-** return values might be unset if an error occurs.
+** describes that file descriptor. Create new ones if necessary. The
+** return values might be uninitialized if an error occurs.
**
** Return the number of errors.
*/
rc = fstat(fd, &statbuf);
if( rc!=0 ) return 1;
+ assert( sqlite3OsInMutex() );
memset(&key1, 0, sizeof(key1));
key1.dev = statbuf.st_dev;
key1.ino = statbuf.st_ino;
pLock->nRef++;
}
*ppLock = pLock;
- pOpen = (struct openCnt*)sqlite3HashFind(&openHash, &key2, sizeof(key2));
- if( pOpen==0 ){
- struct openCnt *pOld;
- pOpen = sqliteMallocRaw( sizeof(*pOpen) );
+ if( ppOpen!=0 ){
+ pOpen = (struct openCnt*)sqlite3HashFind(&openHash, &key2, sizeof(key2));
if( pOpen==0 ){
- releaseLockInfo(pLock);
- rc = 1;
- goto exit_findlockinfo;
- }
- pOpen->key = key2;
- pOpen->nRef = 1;
- pOpen->nLock = 0;
- pOpen->nPending = 0;
- pOpen->aPending = 0;
- pOld = sqlite3HashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen);
- if( pOld!=0 ){
- assert( pOld==pOpen );
- sqliteFree(pOpen);
- releaseLockInfo(pLock);
- rc = 1;
- goto exit_findlockinfo;
+ struct openCnt *pOld;
+ pOpen = sqliteMallocRaw( sizeof(*pOpen) );
+ if( pOpen==0 ){
+ releaseLockInfo(pLock);
+ rc = 1;
+ goto exit_findlockinfo;
+ }
+ pOpen->key = key2;
+ pOpen->nRef = 1;
+ pOpen->nLock = 0;
+ pOpen->nPending = 0;
+ pOpen->aPending = 0;
+ pOld = sqlite3HashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen);
+ if( pOld!=0 ){
+ assert( pOld==pOpen );
+ sqliteFree(pOpen);
+ releaseLockInfo(pLock);
+ rc = 1;
+ goto exit_findlockinfo;
+ }
+ }else{
+ pOpen->nRef++;
}
- }else{
- pOpen->nRef++;
+ *ppOpen = pOpen;
}
- *ppOpen = pOpen;
exit_findlockinfo:
return rc;
}
+/*
+** If we are currently in a different thread than the thread that the
+** unixFile argument belongs to, then transfer ownership of the unixFile
+** over to the current thread.
+**
+** A unixFile is only owned by a thread on systems where one thread is
+** unable to override locks created by a different thread. RedHat9 is
+** an example of such a system.
+**
+** Ownership transfer is only allowed if the unixFile is currently unlocked.
+** If the unixFile is locked and an ownership is wrong, then return
+** SQLITE_MISUSE. Otherwise return SQLITE_OK.
+*/
+#ifdef SQLITE_UNIX_THREADS
+static int transferOwnership(unixFile *pFile){
+ pthread_t hSelf;
+ if( threadsOverrideEachOthersLocks ){
+ /* Ownership transfers not needed on this system */
+ return SQLITE_OK;
+ }
+ hSelf = pthread_self();
+ if( pthread_equal(pFile->tid, hSelf) ){
+ /* We are still in the same thread */
+ return SQLITE_OK;
+ }
+ if( pFile->locktype!=NO_LOCK ){
+ /* We cannot change ownership while we are holding a lock! */
+ return SQLITE_MISUSE;
+ }
+ pFile->tid = hSelf;
+ releaseLockInfo(pFile->pLock);
+ return findLockInfo(pFile->h, &pFile->pLock, 0);
+}
+#else
+# define transferOwnership(X) SQLITE_OK
+#endif
+
/*
** Delete the named file
*/
unixFile *pFile = (unixFile*)id;
assert( pFile );
- if( CHECK_THREADID(pFile) ) return SQLITE_MISUSE;
sqlite3OsEnterMutex(); /* Because pFile->pLock is shared across threads */
/* Check if a thread in this process holds such a lock */
TRACE7("LOCK %d %s was %s(%s,%d) pid=%d\n", pFile->h,
locktypeName(locktype), locktypeName(pFile->locktype),
locktypeName(pLock->locktype), pLock->cnt , getpid());
- if( CHECK_THREADID(pFile) ) return SQLITE_MISUSE;
/* If there is already a lock of this type or more restrictive on the
** OsFile, do nothing. Don't use the end_lock: exit path, as
*/
sqlite3OsEnterMutex();
+ /* Make sure the current thread owns the pFile.
+ */
+ rc = transferOwnership(pFile);
+ if( rc!=SQLITE_OK ){
+ sqlite3OsLeaveMutex();
+ return rc;
+ }
+
/* If some thread using this PID has a lock via a different OsFile*
** handle that precludes the requested lock, return BUSY.
*/
assert( pFile );
TRACE7("UNLOCK %d %d was %d(%d,%d) pid=%d\n", pFile->h, locktype,
pFile->locktype, pFile->pLock->locktype, pFile->pLock->cnt, getpid());
- if( CHECK_THREADID(pFile) ) return SQLITE_MISUSE;
assert( locktype<=SHARED_LOCK );
if( pFile->locktype<=locktype ){
return SQLITE_OK;
}
+ if( CHECK_THREADID(pFile) ) return SQLITE_MISUSE;
sqlite3OsEnterMutex();
pLock = pFile->pLock;
assert( pLock->cnt!=0 );
*/
static int unixClose(OsFile **pId){
unixFile *id = (unixFile*)*pId;
+ int rc;
+
if( !id ) return SQLITE_OK;
- if( CHECK_THREADID(id) ) return SQLITE_MISUSE;
- unixUnlock(*pId, NO_LOCK);
+ rc = unixUnlock(*pId, NO_LOCK);
+ if( rc ) return rc;
if( id->dirfd>=0 ) close(id->dirfd);
id->dirfd = -1;
sqlite3OsEnterMutex();
pNew = sqliteMalloc( sizeof(unixFile) );
if( pNew==0 ){
close(pInit->h);
+ sqlite3OsEnterMutex();
releaseLockInfo(pInit->pLock);
releaseOpenCnt(pInit->pOpen);
+ sqlite3OsLeaveMutex();
*pId = 0;
return SQLITE_NOMEM;
}else{
** The configure script will never generate a Makefile with the option
** above. You will need to manually modify the Makefile if you want to
** include any of the code from this file in your project. Or, at your
-** option, you may want to copy and paste the code from this file and
+** option, you may copy and paste the code from this file and
** thereby avoiding a recompile of SQLite.
**
**
**
** (2) Beginning with SQLite version 3.3.0, when two or more
** connections to the same database occur within the same thread,
-** they will share their database cache. This reduces I/O
-** and memory requirements.
+** they can optionally share their database cache. This reduces
+** I/O and memory requirements. Cache shared is controlled using
+** the sqlite3_enable_shared_cache() API.
**
** (3) Database connections on a shared cache use table-level locking
** instead of file-level locking for improved concurrency.
** These interfaces work exactly like the standard core SQLite interfaces
** having the same names without the "_client_" infix. Many other SQLite
** interfaces can be used directly without having to send messages to the
-** server. The following interfaces fall into this second category:
+** server as long as SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined.
+** The following interfaces fall into this second category:
**
** sqlite3_bind_*
** sqlite3_changes
** sqlite3_errcode
** sqlite3_errmsg
** sqlite3_last_insert_rowid
-** sqlite3_libversion
-** sqlite3_mprintf
** sqlite3_total_changes
** sqlite3_transfer_bindings
-** sqlite3_vmprintf
**
** A single SQLite connection (an sqlite3* object) or an SQLite statement
** (an sqlite3_stmt* object) should only be passed to a single interface
-** function at a time. The connections and statements can be freely used
-** by any thread as long as only one thread is using them at a time.
+** function at a time. The connections and statements can be passed from
+** any thread to any of the functions listed in the second group above as
+** long as the same connection is not in use by two threads at once and
+** as long as SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined. Additional
+** information about the SQLITE_ENABLE_MEMORY_MANAGEMENT constraint is
+** below.
**
** The busy handler for all database connections should remain turned
** off. That means that any lock contention will cause the associated
** the queue to be tried again later. But such enhanced processing is
** not included here, in order to keep the example simple.
**
-** This code assumes the use of pthreads. Pthreads implementations
-** are available for windows. (See, for example
+** This example code assumes the use of pthreads. Pthreads
+** implementations are available for windows. (See, for example
** http://sourceware.org/pthreads-win32/announcement.html.) Or, you
** can translate the locking and thread synchronization code to use
** windows primitives easily enough. The details are left as an
** exercise to the reader.
+**
+**** Restrictions Associated With SQLITE_ENABLE_MEMORY_MANAGEMENT ****
+**
+** If you compile with SQLITE_ENABLE_MEMORY_MANAGEMENT defined, then
+** SQLite includes code that tracks how much memory is being used by
+** each thread. These memory counts can become confused if memory
+** is allocated by one thread and then freed by another. For that
+** reason, when SQLITE_ENABLE_MEMORY_MANAGEMENT is used, all operations
+** that might allocate or free memory should be performanced in the same
+** thread that originally created the database connection. In that case,
+** many of the operations that are listed above as safe to be performed
+** in separate threads would need to be sent over to the server to be
+** done there. If SQLITE_ENABLE_MEMORY_MANAGEMENT is defined, then
+** the following functions can be used safely from different threads
+** without messing up the allocation counts:
+**
+** sqlite3_bind_parameter_name
+** sqlite3_bind_parameter_index
+** sqlite3_changes
+** sqlite3_column_blob
+** sqlite3_column_count
+** sqlite3_complete
+** sqlite3_data_count
+** sqlite3_db_handle
+** sqlite3_errcode
+** sqlite3_errmsg
+** sqlite3_last_insert_rowid
+** sqlite3_total_changes
+**
+** The remaining functions are not thread-safe when memory management
+** is enabled. So one would have to define some new interface routines
+** along the following lines:
+**
+** sqlite3_client_bind_*
+** sqlite3_client_clear_bindings
+** sqlite3_client_column_*
+** sqlite3_client_create_collation
+** sqlite3_client_create_function
+** sqlite3_client_transfer_bindings
+**
+** The example code in this file is intended for use with memory
+** management turned off. So the implementation of these additional
+** client interfaces is left as an exercise to the reader.
+**
+** It may seem surprising to the reader that the list of safe functions
+** above does not include things like sqlite3_bind_int() or
+** sqlite3_column_int(). But those routines might, in fact, allocate
+** or deallocate memory. In the case of sqlite3_bind_int(), if the
+** parameter was previously bound to a string that string might need
+** to be deallocated before the new integer value is inserted. In
+** the case of sqlite3_column_int(), the value of the column might be
+** a UTF-16 string which will need to be converted to UTF-8 then into
+** an integer.
*/
/*
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
-** $Id: test1.c,v 1.189 2006/01/11 23:40:34 drh Exp $
+** $Id: test1.c,v 1.190 2006/01/15 00:13:16 drh Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
extern int sqlite3_memMax;
extern int sqlite3_like_count;
extern int sqlite3_tsd_count;
+#if OS_UNIX && defined(SQLITE_TEST) && defined(THREADSAFE) && THREADSAFE
+ extern int threadsOverrideEachOthersLocks;
+#endif
#if OS_WIN
extern int sqlite3_os_type;
#endif
(char*)&sqlite3_os_trace, TCL_LINK_INT);
Tcl_LinkVar(interp, "sqlite3_tsd_count",
(char*)&sqlite3_tsd_count, TCL_LINK_INT);
+#if OS_UNIX && defined(SQLITE_TEST) && defined(THREADSAFE) && THREADSAFE
+ Tcl_LinkVar(interp, "threadsOverrideEachOthersLocks",
+ (char*)&threadsOverrideEachOthersLocks, TCL_LINK_INT);
+#endif
#ifndef SQLITE_OMIT_UTF16
Tcl_LinkVar(interp, "sqlite_last_needed_collation",
(char*)&pzNeededCollation, TCL_LINK_STRING|TCL_LINK_READ_ONLY);
#
# This file is derived from thread1.test
#
-# $Id: server1.test,v 1.3 2006/01/10 20:36:40 drh Exp $
+# $Id: server1.test,v 1.4 2006/01/15 00:13:16 drh Exp $
set testdir [file dirname $argv0]
return
}
+# The sample server implementation does not work right when memory
+# management is enabled.
+#
+ifcapable memorymanage {
+ finish_test
+ return
+}
+
# Create some data to work with
#
do_test server1-1.1 {
projects / thirdparty / sqlite.git / commitdiff
