| Index: third_party/sqlite/test/threadtest1.c
|
| ===================================================================
|
| --- third_party/sqlite/test/threadtest1.c (revision 56608)
|
| +++ third_party/sqlite/test/threadtest1.c (working copy)
|
| @@ -1,289 +0,0 @@
|
| -/*
|
| -** 2002 January 15
|
| -**
|
| -** The author disclaims copyright to this source code. In place of
|
| -** a legal notice, here is a blessing:
|
| -**
|
| -** May you do good and not evil.
|
| -** May you find forgiveness for yourself and forgive others.
|
| -** May you share freely, never taking more than you give.
|
| -**
|
| -*************************************************************************
|
| -** This file implements a simple standalone program used to test whether
|
| -** or not the SQLite library is threadsafe.
|
| -**
|
| -** Testing the thread safety of SQLite is difficult because there are very
|
| -** few places in the code that are even potentially unsafe, and those
|
| -** places execute for very short periods of time. So even if the library
|
| -** is compiled with its mutexes disabled, it is likely to work correctly
|
| -** in a multi-threaded program most of the time.
|
| -**
|
| -** This file is NOT part of the standard SQLite library. It is used for
|
| -** testing only.
|
| -*/
|
| -#include "sqlite.h"
|
| -#include <pthread.h>
|
| -#include <sched.h>
|
| -#include <stdio.h>
|
| -#include <stdlib.h>
|
| -#include <string.h>
|
| -#include <unistd.h>
|
| -
|
| -/*
|
| -** Enable for tracing
|
| -*/
|
| -static int verbose = 0;
|
| -
|
| -/*
|
| -** Come here to die.
|
| -*/
|
| -static void Exit(int rc){
|
| - exit(rc);
|
| -}
|
| -
|
| -extern char *sqlite3_mprintf(const char *zFormat, ...);
|
| -extern char *sqlite3_vmprintf(const char *zFormat, va_list);
|
| -
|
| -/*
|
| -** When a lock occurs, yield.
|
| -*/
|
| -static int db_is_locked(void *NotUsed, int iCount){
|
| - /* sched_yield(); */
|
| - if( verbose ) printf("BUSY %s #%d\n", (char*)NotUsed, iCount);
|
| - usleep(100);
|
| - return iCount<25;
|
| -}
|
| -
|
| -/*
|
| -** Used to accumulate query results by db_query()
|
| -*/
|
| -struct QueryResult {
|
| - const char *zFile; /* Filename - used for error reporting */
|
| - int nElem; /* Number of used entries in azElem[] */
|
| - int nAlloc; /* Number of slots allocated for azElem[] */
|
| - char **azElem; /* The result of the query */
|
| -};
|
| -
|
| -/*
|
| -** The callback function for db_query
|
| -*/
|
| -static int db_query_callback(
|
| - void *pUser, /* Pointer to the QueryResult structure */
|
| - int nArg, /* Number of columns in this result row */
|
| - char **azArg, /* Text of data in all columns */
|
| - char **NotUsed /* Names of the columns */
|
| -){
|
| - struct QueryResult *pResult = (struct QueryResult*)pUser;
|
| - int i;
|
| - if( pResult->nElem + nArg >= pResult->nAlloc ){
|
| - if( pResult->nAlloc==0 ){
|
| - pResult->nAlloc = nArg+1;
|
| - }else{
|
| - pResult->nAlloc = pResult->nAlloc*2 + nArg + 1;
|
| - }
|
| - pResult->azElem = realloc( pResult->azElem, pResult->nAlloc*sizeof(char*));
|
| - if( pResult->azElem==0 ){
|
| - fprintf(stdout,"%s: malloc failed\n", pResult->zFile);
|
| - return 1;
|
| - }
|
| - }
|
| - if( azArg==0 ) return 0;
|
| - for(i=0; i<nArg; i++){
|
| - pResult->azElem[pResult->nElem++] =
|
| - sqlite3_mprintf("%s",azArg[i] ? azArg[i] : "");
|
| - }
|
| - return 0;
|
| -}
|
| -
|
| -/*
|
| -** Execute a query against the database. NULL values are returned
|
| -** as an empty string. The list is terminated by a single NULL pointer.
|
| -*/
|
| -char **db_query(sqlite *db, const char *zFile, const char *zFormat, ...){
|
| - char *zSql;
|
| - int rc;
|
| - char *zErrMsg = 0;
|
| - va_list ap;
|
| - struct QueryResult sResult;
|
| - va_start(ap, zFormat);
|
| - zSql = sqlite3_vmprintf(zFormat, ap);
|
| - va_end(ap);
|
| - memset(&sResult, 0, sizeof(sResult));
|
| - sResult.zFile = zFile;
|
| - if( verbose ) printf("QUERY %s: %s\n", zFile, zSql);
|
| - rc = sqlite3_exec(db, zSql, db_query_callback, &sResult, &zErrMsg);
|
| - if( rc==SQLITE_SCHEMA ){
|
| - if( zErrMsg ) free(zErrMsg);
|
| - rc = sqlite3_exec(db, zSql, db_query_callback, &sResult, &zErrMsg);
|
| - }
|
| - if( verbose ) printf("DONE %s %s\n", zFile, zSql);
|
| - if( zErrMsg ){
|
| - fprintf(stdout,"%s: query failed: %s - %s\n", zFile, zSql, zErrMsg);
|
| - free(zErrMsg);
|
| - free(zSql);
|
| - Exit(1);
|
| - }
|
| - sqlite3_free(zSql);
|
| - if( sResult.azElem==0 ){
|
| - db_query_callback(&sResult, 0, 0, 0);
|
| - }
|
| - sResult.azElem[sResult.nElem] = 0;
|
| - return sResult.azElem;
|
| -}
|
| -
|
| -/*
|
| -** Execute an SQL statement.
|
| -*/
|
| -void db_execute(sqlite *db, const char *zFile, const char *zFormat, ...){
|
| - char *zSql;
|
| - int rc;
|
| - char *zErrMsg = 0;
|
| - va_list ap;
|
| - va_start(ap, zFormat);
|
| - zSql = sqlite3_vmprintf(zFormat, ap);
|
| - va_end(ap);
|
| - if( verbose ) printf("EXEC %s: %s\n", zFile, zSql);
|
| - do{
|
| - rc = sqlite3_exec(db, zSql, 0, 0, &zErrMsg);
|
| - }while( rc==SQLITE_BUSY );
|
| - if( verbose ) printf("DONE %s: %s\n", zFile, zSql);
|
| - if( zErrMsg ){
|
| - fprintf(stdout,"%s: command failed: %s - %s\n", zFile, zSql, zErrMsg);
|
| - free(zErrMsg);
|
| - sqlite3_free(zSql);
|
| - Exit(1);
|
| - }
|
| - sqlite3_free(zSql);
|
| -}
|
| -
|
| -/*
|
| -** Free the results of a db_query() call.
|
| -*/
|
| -void db_query_free(char **az){
|
| - int i;
|
| - for(i=0; az[i]; i++){
|
| - sqlite3_free(az[i]);
|
| - }
|
| - free(az);
|
| -}
|
| -
|
| -/*
|
| -** Check results
|
| -*/
|
| -void db_check(const char *zFile, const char *zMsg, char **az, ...){
|
| - va_list ap;
|
| - int i;
|
| - char *z;
|
| - va_start(ap, az);
|
| - for(i=0; (z = va_arg(ap, char*))!=0; i++){
|
| - if( az[i]==0 || strcmp(az[i],z)!=0 ){
|
| - fprintf(stdout,"%s: %s: bad result in column %d: %s\n",
|
| - zFile, zMsg, i+1, az[i]);
|
| - db_query_free(az);
|
| - Exit(1);
|
| - }
|
| - }
|
| - va_end(ap);
|
| - db_query_free(az);
|
| -}
|
| -
|
| -pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
|
| -pthread_cond_t sig = PTHREAD_COND_INITIALIZER;
|
| -int thread_cnt = 0;
|
| -
|
| -static void *worker_bee(void *pArg){
|
| - const char *zFilename = (char*)pArg;
|
| - char *azErr;
|
| - int i, cnt;
|
| - int t = atoi(zFilename);
|
| - char **az;
|
| - sqlite *db;
|
| -
|
| - pthread_mutex_lock(&lock);
|
| - thread_cnt++;
|
| - pthread_mutex_unlock(&lock);
|
| - printf("%s: START\n", zFilename);
|
| - fflush(stdout);
|
| - for(cnt=0; cnt<10; cnt++){
|
| - sqlite3_open(&zFilename[2], &db);
|
| - if( db==0 ){
|
| - fprintf(stdout,"%s: can't open\n", zFilename);
|
| - Exit(1);
|
| - }
|
| - sqlite3_busy_handler(db, db_is_locked, zFilename);
|
| - db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t);
|
| - for(i=1; i<=100; i++){
|
| - db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);",
|
| - t, i, i*2, i*i);
|
| - }
|
| - az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t);
|
| - db_check(zFilename, "tX size", az, "100", 0);
|
| - az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
|
| - db_check(zFilename, "tX avg", az, "101", 0);
|
| - db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t);
|
| - az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
|
| - db_check(zFilename, "tX avg2", az, "51", 0);
|
| - for(i=1; i<=50; i++){
|
| - char z1[30], z2[30];
|
| - az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i);
|
| - sprintf(z1, "%d", i*2);
|
| - sprintf(z2, "%d", i*i);
|
| - db_check(zFilename, "readback", az, z1, z2, 0);
|
| - }
|
| - db_execute(db, zFilename, "DROP TABLE t%d;", t);
|
| - sqlite3_close(db);
|
| - }
|
| - printf("%s: END\n", zFilename);
|
| - /* unlink(zFilename); */
|
| - fflush(stdout);
|
| - pthread_mutex_lock(&lock);
|
| - thread_cnt--;
|
| - if( thread_cnt<=0 ){
|
| - pthread_cond_signal(&sig);
|
| - }
|
| - pthread_mutex_unlock(&lock);
|
| - return 0;
|
| -}
|
| -
|
| -int main(int argc, char **argv){
|
| - char *zFile;
|
| - int i, n;
|
| - pthread_t id;
|
| - if( argc>2 && strcmp(argv[1], "-v")==0 ){
|
| - verbose = 1;
|
| - argc--;
|
| - argv++;
|
| - }
|
| - if( argc<2 || (n=atoi(argv[1]))<1 ) n = 10;
|
| - for(i=0; i<n; i++){
|
| - char zBuf[200];
|
| - sprintf(zBuf, "testdb-%d", (i+1)/2);
|
| - unlink(zBuf);
|
| - }
|
| - for(i=0; i<n; i++){
|
| - zFile = sqlite3_mprintf("%d.testdb-%d", i%2+1, (i+2)/2);
|
| - if( (i%2)==0 ){
|
| - /* Remove both the database file and any old journal for the file
|
| - ** being used by this thread and the next one. */
|
| - char *zDb = &zFile[2];
|
| - char *zJournal = sqlite3_mprintf("%s-journal", zDb);
|
| - unlink(zDb);
|
| - unlink(zJournal);
|
| - free(zJournal);
|
| - }
|
| -
|
| - pthread_create(&id, 0, worker_bee, (void*)zFile);
|
| - pthread_detach(id);
|
| - }
|
| - pthread_mutex_lock(&lock);
|
| - while( thread_cnt>0 ){
|
| - pthread_cond_wait(&sig, &lock);
|
| - }
|
| - pthread_mutex_unlock(&lock);
|
| - for(i=0; i<n; i++){
|
| - char zBuf[200];
|
| - sprintf(zBuf, "testdb-%d", (i+1)/2);
|
| - unlink(zBuf);
|
| - }
|
| - return 0;
|
| -}
|
|
|