[sql] Import reference version of SQLite 3.8.7.4.

third_party/sqlite/sqlite-src-3080704/src/test7.c

 /*
 ** 2006 January 09
 **
 ** 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.
 **
@@ skipping 22 matching lines @@
 */
 int sqlite3_client_open(const char*, sqlite3**);
 int sqlite3_client_prepare(sqlite3*,const char*,int,
                            sqlite3_stmt**,const char**);
 int sqlite3_client_step(sqlite3_stmt*);
 int sqlite3_client_reset(sqlite3_stmt*);
 int sqlite3_client_finalize(sqlite3_stmt*);
 int sqlite3_client_close(sqlite3*);
 int sqlite3_server_start(void);
 int sqlite3_server_stop(void);
+void sqlite3_server_start2(int *pnDecr);
 
 /*
 ** Each thread is controlled by an instance of the following
 ** structure.
 */
 typedef struct Thread Thread;
 struct Thread {
   /* The first group of fields are writable by the supervisor thread
   ** and read-only to the client threads
   */
   char *zFilename;         /* Name of database file */
   void (*xOp)(Thread*);    /* next operation to do */
   char *zArg;              /* argument usable by xOp */
   volatile int opnum;      /* Operation number */
   volatile int busy;       /* True if this thread is in use */
 
   /* The next group of fields are writable by the client threads 
   ** but read-only to the superviser thread.
   */
   volatile int completed;  /* Number of operations completed */
   sqlite3 *db;             /* Open database */
   sqlite3_stmt *pStmt;     /* Pending operation */
   char *zErr;              /* operation error */
   char *zStaticErr;        /* Static error message */
   int rc;                  /* operation return code */
   int argc;                /* number of columns in result */
   const char *argv[100];   /* result columns */
   const char *colv[100];   /* result column names */
+
+  /* Initialized to 1 by the supervisor thread when the client is 
+  ** created, and then deemed read-only to the supervisor thread. 
+  ** Is set to 0 by the server thread belonging to this client 
+  ** just before it exits.  
+  */
+  int nServer;             /* Number of server threads running */
 };
 
 /*
 ** There can be as many as 26 threads running at once.  Each is named
 ** by a capital letter: A, B, C, ..., Y, Z.
 */
 #define N_THREAD 26
 static Thread threadset[N_THREAD];
 
 /*
@@ skipping 87 matching lines @@
   threadset[i].opnum = 1;
   threadset[i].completed = 0;
   rc = pthread_create(&x, 0, client_main, &threadset[i]);
   if( rc ){
     Tcl_AppendResult(interp, "failed to create the thread", 0);
     sqlite3_free(threadset[i].zFilename);
     threadset[i].busy = 0;
     return TCL_ERROR;
   }
   pthread_detach(x);
-  sqlite3_server_start();
+  if( threadset[i].nServer==0 ){
+    threadset[i].nServer = 1;
+    sqlite3_server_start2(&threadset[i].nServer);
+  }
   return TCL_OK;
 }
 
 /*
 ** Wait for a thread to reach its idle state.
 */
 static void client_wait(Thread *p){
   while( p->opnum>p->completed ) sched_yield();
 }
 
@@ skipping 72 matching lines @@
       Tcl_AppendResult(interp, "no such thread", 0);
       return TCL_ERROR;
     }
     stop_thread(&threadset[i]);
   }
 
   /* If no client threads are still running, also stop the server */
   for(i=0; i<N_THREAD && threadset[i].busy==0; i++){}
   if( i>=N_THREAD ){
     sqlite3_server_stop();
+    while( 1 ){
+      for(i=0; i<N_THREAD && threadset[i].nServer==0; i++);
+      if( i==N_THREAD ) break;
+      sched_yield();
+    }
   }
   return TCL_OK;
 }
 
 /*
 ** Usage: client_argc  ID
 **
 ** Wait on the most recent client_step to complete, then return the
 ** number of columns in the result set.
 */
@@ skipping 88 matching lines @@
   if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
   client_wait(&threadset[i]);
   if( n<0 || n>=threadset[i].argc ){
     Tcl_AppendResult(interp, "column number out of range", 0);
     return TCL_ERROR;
   }
   Tcl_AppendResult(interp, threadset[i].colv[n], 0);
   return TCL_OK;
 }
 
+extern const char *sqlite3ErrName(int);
+
 /*
 ** Usage: client_result  ID
 **
 ** Wait on the most recent operation to complete, then return the
 ** result code from that operation.
 */
 static int tcl_client_result(
   void *NotUsed,
   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
   int argc,              /* Number of arguments */
   const char **argv      /* Text of each argument */
 ){
   int i;
   const char *zName;
 
   if( argc!=2 ){
     Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
        " ID", 0);
     return TCL_ERROR;
   }
   i = parse_client_id(interp, argv[1]);
   if( i<0 ) return TCL_ERROR;
   if( !threadset[i].busy ){
     Tcl_AppendResult(interp, "no such thread", 0);
     return TCL_ERROR;
   }
   client_wait(&threadset[i]);
-  switch( threadset[i].rc ){
-    case SQLITE_OK:         zName = "SQLITE_OK";          break;
-    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
-    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
-    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
-    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
-    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
-    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
-    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
-    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
-    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
-    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
-    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
-    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
-    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
-    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
-    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
-    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
-    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
-    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
-    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
-    case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
-    case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
-    case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;
-    case SQLITE_ROW:        zName = "SQLITE_ROW";         break;
-    case SQLITE_DONE:       zName = "SQLITE_DONE";        break;
-    default:                zName = "SQLITE_Unknown";     break;
-  }
+  zName = sqlite3ErrName(threadset[i].rc);
   Tcl_AppendResult(interp, zName, 0);
   return TCL_OK;
 }
 
 /*
 ** Usage: client_error  ID
 **
 ** Wait on the most recent operation to complete, then return the
 ** error string.
 */
@@ skipping 270 matching lines @@
   int i;
 
   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
     Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
   }
   return TCL_OK;
 }
 #else
 int Sqlitetest7_Init(Tcl_Interp *interp){ return TCL_OK; }
 #endif /* SQLITE_OS_UNIX */