[sql] Import reference version of SQLite 3.10.2.

third_party/sqlite/sqlite-src-3100200/src/test_sqllog.c

 /*
 ** 2012 November 26
 **
 ** 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 28 matching lines @@
 **   At runtime, logging is enabled by setting environment variable
 **   SQLITE_SQLLOG_DIR to the name of a directory in which to store logged 
 **   data. The logging directory must already exist.
 **
 **   Usually, if the application opens the same database file more than once
 **   (either by attaching it or by using more than one database handle), only
 **   a single copy is made. This behavior may be overridden (so that a 
 **   separate copy is taken each time the database file is opened or attached)
 **   by setting the environment variable SQLITE_SQLLOG_REUSE_FILES to 0.
 **
+**   If the environment variable SQLITE_SQLLOG_CONDITIONAL is defined, then
+**   logging is only done for database connections if a file named
+**   "<database>-sqllog" exists in the same directly as the main database
+**   file when it is first opened ("<database>" is replaced by the actual 
+**   name of the main database file).
+**
 ** OUTPUT:
 **
 **   The SQLITE_SQLLOG_DIR is populated with three types of files:
 **
 **      sqllog_N.db   - Copies of database files. N may be any integer.
 **
 **      sqllog_N.sql  - A list of SQL statements executed by a single
 **                      connection. N may be any integer.
 **
 **      sqllog.idx    - An index mapping from integer N to a database
@@ skipping 22 matching lines @@
 #if SQLITE_OS_WIN
   return (int)_getpid();
 #else
   return (int)getpid();
 #endif
 }
 
 /* Names of environment variables to be used */
 #define ENVIRONMENT_VARIABLE1_NAME "SQLITE_SQLLOG_DIR"
 #define ENVIRONMENT_VARIABLE2_NAME "SQLITE_SQLLOG_REUSE_FILES"
+#define ENVIRONMENT_VARIABLE3_NAME "SQLITE_SQLLOG_CONDITIONAL"
 
 /* Assume that all database and database file names are shorted than this. */
 #define SQLLOG_NAMESZ 512
 
 /* Maximum number of simultaneous database connections the process may
 ** open (if any more are opened an error is logged using sqlite3_log()
 ** and processing is halted).
 */
 #define MAX_CONNECTIONS 256
 
 /* There is one instance of this object for each SQLite database connection
 ** that is being logged.
 */
 struct SLConn {
   int isErr;                      /* True if an error has occurred */
   sqlite3 *db;                    /* Connection handle */
   int iLog;                       /* First integer value used in file names */
   FILE *fd;                       /* File descriptor for log file */
 };
 
 /* This object is a singleton that keeps track of all data loggers.
 */
 static struct SLGlobal {
   /* Protected by MUTEX_STATIC_MASTER */
   sqlite3_mutex *mutex;           /* Recursive mutex */
   int nConn;                      /* Size of aConn[] array */
 
   /* Protected by SLGlobal.mutex */
+  int bConditional;               /* Only trace if *-sqllog file is present */
   int bReuse;                     /* True to avoid extra copies of db files */
   char zPrefix[SQLLOG_NAMESZ];    /* Prefix for all created files */
   char zIdx[SQLLOG_NAMESZ];       /* Full path to *.idx file */
   int iNextLog;                   /* Used to allocate file names */
   int iNextDb;                    /* Used to allocate database file names */
   int bRec;                       /* True if testSqllog() is called rec. */
   int iClock;                     /* Clock value */
   struct SLConn aConn[MAX_CONNECTIONS];
 } sqllogglobal;
 
@@ skipping 79 matching lines @@
 
   if( ferror(fd) ){
     sqlite3_log(SQLITE_IOERR, "sqllogFindFile(): error reading index file");
   }
 
   fclose(fd);
   return zRet;
 }
 
 static int sqllogFindAttached(
-  struct SLConn *p,               /* Database connection */
+  sqlite3 *db,                    /* Database connection */
   const char *zSearch,            /* Name to search for (or NULL) */
   char *zName,                    /* OUT: Name of attached database */
   char *zFile                     /* OUT: Name of attached file */
 ){
   sqlite3_stmt *pStmt;
   int rc;
 
   /* The "PRAGMA database_list" command returns a list of databases in the
   ** order that they were attached. So a newly attached database is 
   ** described by the last row returned.  */
   assert( sqllogglobal.bRec==0 );
   sqllogglobal.bRec = 1;
-  rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
+  rc = sqlite3_prepare_v2(db, "PRAGMA database_list", -1, &pStmt, 0);
   if( rc==SQLITE_OK ){
     while( SQLITE_ROW==sqlite3_step(pStmt) ){
       const char *zVal1; int nVal1;
       const char *zVal2; int nVal2;
 
       zVal1 = (const char*)sqlite3_column_text(pStmt, 1);
       nVal1 = sqlite3_column_bytes(pStmt, 1);
-      memcpy(zName, zVal1, nVal1+1);
+      if( zName ){
+        memcpy(zName, zVal1, nVal1+1);
+      }
 
       zVal2 = (const char*)sqlite3_column_text(pStmt, 2);
       nVal2 = sqlite3_column_bytes(pStmt, 2);
       memcpy(zFile, zVal2, nVal2+1);
 
       if( zSearch && strlen(zSearch)==nVal1 
        && 0==sqlite3_strnicmp(zSearch, zVal1, nVal1)
       ){
         break;
       }
@@ skipping 28 matching lines @@
 **
 ** The SLGlobal.mutex mutex is always held when this function is called.
 */
 static void sqllogCopydb(struct SLConn *p, const char *zSearch, int bLog){
   char zName[SQLLOG_NAMESZ];      /* Attached database name */
   char zFile[SQLLOG_NAMESZ];      /* Database file name */
   char *zFree;
   char *zInit = 0;
   int rc;
 
-  rc = sqllogFindAttached(p, zSearch, zName, zFile);
+  rc = sqllogFindAttached(p->db, zSearch, zName, zFile);
   if( rc!=SQLITE_OK ) return;
 
   if( zFile[0]=='\0' ){
     zInit = sqlite3_mprintf("");
   }else{
     if( sqllogglobal.bReuse ){
       zInit = sqllogFindFile(zFile);
     }else{
       zInit = 0;
     }
@@ skipping 59 matching lines @@
   /* If the log file has not yet been opened, open it now. */
   if( p->fd==0 ){
     char *zLog;
 
     /* If it is still NULL, have global.zPrefix point to a copy of 
     ** environment variable $ENVIRONMENT_VARIABLE1_NAME.  */
     if( sqllogglobal.zPrefix[0]==0 ){
       FILE *fd;
       char *zVar = getenv(ENVIRONMENT_VARIABLE1_NAME);
       if( zVar==0 || strlen(zVar)+10>=(sizeof(sqllogglobal.zPrefix)) ) return;
-      sprintf(sqllogglobal.zPrefix, "%s/sqllog_%d", zVar, getProcessId());
-      sprintf(sqllogglobal.zIdx, "%s.idx", sqllogglobal.zPrefix);
+      sqlite3_snprintf(sizeof(sqllogglobal.zPrefix), sqllogglobal.zPrefix,
+                        "%s/sqllog_%d", zVar, getProcessId());
+      sqlite3_snprintf(sizeof(sqllogglobal.zIdx), sqllogglobal.zIdx,
+                        "%s.idx", sqllogglobal.zPrefix);
       if( getenv(ENVIRONMENT_VARIABLE2_NAME) ){
         sqllogglobal.bReuse = atoi(getenv(ENVIRONMENT_VARIABLE2_NAME));
       }
       fd = fopen(sqllogglobal.zIdx, "w");
       if( fd ) fclose(fd);
     }
 
     /* Open the log file */
     zLog = sqlite3_mprintf("%s_%d.sql", sqllogglobal.zPrefix, p->iLog);
     p->fd = fopen(zLog, "w");
@@ skipping 17 matching lines @@
   if( nFirst!=6 || 0!=sqlite3_strnicmp("ATTACH", zFirst, 6) ){
     /* Not an ATTACH statement. Write this directly to the log. */
     fprintf(p->fd, "%s; -- clock=%d\n", zSql, sqllogglobal.iClock++);
   }else{
     /* This is an ATTACH statement. Copy the database. */
     sqllogCopydb(p, 0, 1);
   }
 }
 
 /*
+** The database handle passed as the only argument has just been opened.
+** Return true if this module should log initial databases and SQL 
+** statements for this connection, or false otherwise.
+**
+** If an error occurs, sqlite3_log() is invoked to report it to the user
+** and zero returned.
+*/
+static int sqllogTraceDb(sqlite3 *db){
+  int bRet = 1;
+  if( sqllogglobal.bConditional ){
+    char zFile[SQLLOG_NAMESZ];      /* Attached database name */
+    int rc = sqllogFindAttached(db, "main", 0, zFile);
+    if( rc==SQLITE_OK ){
+      int nFile = strlen(zFile);
+      if( (SQLLOG_NAMESZ-nFile)<8 ){
+        sqlite3_log(SQLITE_IOERR, 
+            "sqllogTraceDb(): database name too long (%d bytes)", nFile
+        );
+        bRet = 0;
+      }else{
+        memcpy(&zFile[nFile], "-sqllog", 8);
+        bRet = !access(zFile, F_OK);
+      }
+    }
+  }
+  return bRet;
+}
+
+/*
 ** The SQLITE_CONFIG_SQLLOG callback registered by sqlite3_init_sqllog().
 **
 ** The eType parameter has the following values:
 **
 **    0:  Opening a new database connection.  zSql is the name of the
 **        file being opened.  db is a pointer to the newly created database
 **        connection.
 **
 **    1:  An SQL statement has run to completion.  zSql is the text of the
 **        SQL statement with all parameters expanded to their actual values.
@@ skipping 13 matching lines @@
 
   assert( eType==0 || eType==1 || eType==2 );
   assert( (eType==2)==(zSql==0) );
 
   /* This is a database open command. */
   if( eType==0 ){
     sqlite3_mutex_enter(master);
     if( sqllogglobal.mutex==0 ){
       sqllogglobal.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
     }
-    p = &sqllogglobal.aConn[sqllogglobal.nConn++];
-    p->fd = 0;
-    p->db = db;
-    p->iLog = sqllogglobal.iNextLog++;
     sqlite3_mutex_leave(master);
 
-    /* Open the log and take a copy of the main database file */
     sqlite3_mutex_enter(sqllogglobal.mutex);
-    if( sqllogglobal.bRec==0 ){
+    if( sqllogglobal.bRec==0 && sqllogTraceDb(db) ){
+
+      sqlite3_mutex_enter(master);
+      p = &sqllogglobal.aConn[sqllogglobal.nConn++];
+      p->fd = 0;
+      p->db = db;
+      p->iLog = sqllogglobal.iNextLog++;
+      sqlite3_mutex_leave(master);
+
+      /* Open the log and take a copy of the main database file */
       sqllogOpenlog(p);
       if( p->fd ) sqllogCopydb(p, "main", 0);
     }
     sqlite3_mutex_leave(sqllogglobal.mutex);
   }
 
   else{
 
     int i;
     for(i=0; i<sqllogglobal.nConn; i++){
       p = &sqllogglobal.aConn[i];
       if( p->db==db ) break;
     }
-    if( i==sqllogglobal.nConn ) return;
 
     /* A database handle close command */
     if( eType==2 ){
       sqlite3_mutex_enter(master);
-      if( p->fd ) fclose(p->fd);
-      p->db = 0;
-      p->fd = 0;
+      if( i<sqllogglobal.nConn ){
+        if( p->fd ) fclose(p->fd);
+        p->db = 0;
+        p->fd = 0;
+        sqllogglobal.nConn--;
+      }
 
-      sqllogglobal.nConn--;
       if( sqllogglobal.nConn==0 ){
         sqlite3_mutex_free(sqllogglobal.mutex);
         sqllogglobal.mutex = 0;
-      }else{
+      }else if( i<sqllogglobal.nConn ){
         int nShift = &sqllogglobal.aConn[sqllogglobal.nConn] - p;
         if( nShift>0 ){
           memmove(p, &p[1], nShift*sizeof(struct SLConn));
         }
       }
       sqlite3_mutex_leave(master);
 
     /* An ordinary SQL command. */
-    }else if( p->fd ){
+    }else if( i<sqllogglobal.nConn && p->fd ){
       sqlite3_mutex_enter(sqllogglobal.mutex);
       if( sqllogglobal.bRec==0 ){
         testSqllogStmt(p, zSql);
       }
       sqlite3_mutex_leave(sqllogglobal.mutex);
     }
   }
 }
 
 /*
 ** This function is called either before sqlite3_initialized() or by it.
 ** It checks if the SQLITE_SQLLOG_DIR variable is defined, and if so 
 ** registers an SQLITE_CONFIG_SQLLOG callback to record the applications
 ** database activity.
 */
 void sqlite3_init_sqllog(void){
   if( getenv(ENVIRONMENT_VARIABLE1_NAME) ){
     if( SQLITE_OK==sqlite3_config(SQLITE_CONFIG_SQLLOG, testSqllog, 0) ){
       memset(&sqllogglobal, 0, sizeof(sqllogglobal));
       sqllogglobal.bReuse = 1;
+      if( getenv(ENVIRONMENT_VARIABLE3_NAME) ){
+        sqllogglobal.bConditional = 1;
+      }
     }
   }
 }