SQLite4  Check-in [fd63f9cb75]

  sqlite4AuthFreeAll(db);

  /* Tell the code in notify.c that the connection no longer holds any
  ** locks and does not require any further unlock-notify callbacks.
  */
  sqlite4ConnectionClosed(db);

  /* Delete any collation needed, profile and trace callbacks */
  sqlite4_collation_needed(db, 0, 0, 0);
  sqlite4_profile(db, 0, 0, 0);
  sqlite4_trace(db, 0, 0, 0);
  
  /* Delete tokenizers */
  sqlite4ShutdownFts5(db);

  assert( db->nDb<=2 );
  assert( db->aDb==db->aDbStatic );
  {

** Register a trace function.  The pArg from the previously registered trace
** is returned.  
**
** A NULL trace function means that no tracing is executes.  A non-NULL
** trace is a pointer to a function that is invoked at the start of each
** SQL statement.
*/
void sqlite4_trace(
  sqlite4 *db, 
  void *pArg,
  void (*xTrace)(void*,const char*), 
  void (*xDestroy)(void*)
){
  sqlite4_mutex_enter(db->mutex);
  if( db->xTraceDestroy ){
    db->xTraceDestroy(db->pTraceArg);
  }
  db->xTrace = xTrace;
  db->xTraceDestroy = xDestroy;
  db->pTraceArg = pArg;
  sqlite4_mutex_leave(db->mutex);

}
/*
** Register a profile function.  The pArg from the previously registered 
** profile function is returned.  
**
** A NULL profile function means that no profiling is executes.  A non-NULL
** profile is a pointer to a function that is invoked at the conclusion of
** each SQL statement that is run.
*/
void sqlite4_profile(
  sqlite4 *db,
  void *pArg,
  void (*xProfile)(void*,const char*,sqlite4_uint64),
  void (*xDestroy)(void*)
){
  void *pOld;
  sqlite4_mutex_enter(db->mutex);
  if( db->xProfileDestroy ){
    db->xProfileDestroy(db->pProfileArg);
  }
  db->xProfile = xProfile;
  db->xProfileDestroy = xDestroy;
  db->pProfileArg = pArg;
  sqlite4_mutex_leave(db->mutex);

}
#endif /* SQLITE4_OMIT_TRACE */

/*
** This function returns true if main-memory should be used instead of
** a temporary file for transient pager files and statement journals.
** The value returned depends on the value of db->temp_store (runtime

  
  if( c=='t' && strncmp(azArg[0], "trace", n)==0 && nArg>1 ){
    open_db(p);
    output_file_close(p->traceOut);
    p->traceOut = output_file_open(azArg[1]);
#if !defined(SQLITE4_OMIT_TRACE) && !defined(SQLITE4_OMIT_FLOATING_POINT)
    if( p->traceOut==0 ){
      sqlite4_trace(p->db, 0, 0, 0);
    }else{
      sqlite4_trace(p->db, (void*)p->traceOut, sql_trace_callback, 0);
    }
#endif
  }else
  
  if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
    printf("SQLite %s %s\n" /*extra-version-info*/,
        sqlite4_libversion(), sqlite4_sourceid());

** time is in units of nanoseconds, however the current implementation
** is only capable of millisecond resolution so the six least significant
** digits in the time are meaningless.  Future versions of SQLite
** might provide greater resolution on the profiler callback.  The
** sqlite4_profile() function is considered experimental and is
** subject to change in future versions of SQLite.
*/
void sqlite4_trace(
  sqlite4*, 
  void *, 
  void(*xTrace)(void*,const char*), 
  void(*xDestroy)(void*)
);
void sqlite4_profile(
  sqlite4*,
  void *,
  void(*xProfile)(void*,const char*,sqlite4_uint64),
  void(*xDestroy)(void*)
);

/*
** CAPIREF: Query Progress Callbacks
**
** ^The sqlite4_progress_handler(D,N,X,P) interface causes the callback
** function X to be invoked periodically during long running calls to
** [sqlite4_exec()] and [sqlite4_step()] for

  int nExtension;               /* Number of loaded extensions */
  void **aExtension;            /* Array of shared library handles */
  struct Vdbe *pVdbe;           /* List of active virtual machines */
  int activeVdbeCnt;            /* Number of VDBEs currently executing */
  int writeVdbeCnt;             /* Number of active VDBEs that are writing */
  int vdbeExecCnt;              /* Number of nested calls to VdbeExec() */
  void (*xTrace)(void*,const char*);        /* Trace function */
  void (*xTraceDestroy)(void*);             /* Destructor for trace function */
  void *pTraceArg;                          /* Argument to the trace function */
  void (*xProfile)(void*,const char*,u64);  /* Profiling function */
  void (*xProfileDestroy)(void*);           /* Profile function destructor */
  void *pProfileArg;                        /* Argument to profile function */
#ifndef SQLITE4_OMIT_WAL
  int (*xWalCallback)(void *, sqlite4 *, const char *, int);
  void *pWalArg;
#endif
  void(*xCollNeeded)(void*,sqlite4*,const char*);
  void(*xCollNeededDestroy)(void*);

        memcpy(pDb->zProfile, zProfile, len+1);
      }else{
        pDb->zProfile = 0;
      }
#if !defined(SQLITE4_OMIT_TRACE) && !defined(SQLITE4_OMIT_FLOATING_POINT)
      if( pDb->zProfile ){
        pDb->interp = interp;
        sqlite4_profile(pDb->db, (void*)pDb, DbProfileHandler, 0);
      }else{
        sqlite4_profile(pDb->db, 0, 0, 0);
      }
#endif
    }
    break;
  }

  /*

        memcpy(pDb->zTrace, zTrace, len+1);
      }else{
        pDb->zTrace = 0;
      }
#if !defined(SQLITE4_OMIT_TRACE) && !defined(SQLITE4_OMIT_FLOATING_POINT)
      if( pDb->zTrace ){
        pDb->interp = interp;
        sqlite4_trace(pDb->db, (void*)pDb, DbTraceHandler, 0);
      }else{
        sqlite4_trace(pDb->db, 0, 0, 0);
      }
#endif
    }
    break;
  }

  /*    $db transaction [-deferred|-immediate|-exclusive] SCRIPT

  selectB.test selectC.test selectF.test

  sort.test
  storage1.test

  subquery.test subquery2.test
  substr.test 

  trace2.test trace3.test

  trigger1.test trigger2.test trigger3.test trigger4.test trigger5.test 
  trigger6.test trigger7.test trigger8.test trigger9.test triggerB.test
  triggerC.test

  update.test
  view.test

  }
  Tcl_ResetResult(interp);
  return TCL_OK;
}
/* End of [sqlite4_create_collation] implementation.
********************************************************************/

/*
** Usage: sqlite4_collation_needed DB CALLBACK-PROC DEL-PROC
*/
struct TestNeededX {
  Tcl_Interp *interp;
  Tcl_Obj *pNeeded;
  Tcl_Obj *pDel;
};
typedef struct TestNeededX TestNeededX;

  }

  Tcl_DecrRefCount(p->pNeeded);
  Tcl_DecrRefCount(p->pDel);
  sqlite4_free(0, (void *)p);
}




static int test_collation_needed(
  ClientData clientData,          /* Not used */
  Tcl_Interp *interp,             /* The TCL interpreter */
  int objc,                       /* Number of arguments */
  Tcl_Obj *CONST objv[]           /* Command arguments */
){
  int nByte;                      /* Size of callback scripts in bytes */

  if( rc!=SQLITE4_OK ){
    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite4TestErrorName(rc), -1));
    return TCL_ERROR;
  }
  Tcl_ResetResult(interp);
  return TCL_OK;
}
/* End of [sqlite4_collation_needed] implementation.
********************************************************************/
/*
** Usage: sqlite4_profile DB PROFILE-CMD DEL-CMD
*/
struct TestProfileX {
  Tcl_Interp *interp;
  Tcl_Obj *pProfile;
  Tcl_Obj *pDel;
};
typedef struct TestProfileX TestProfileX;
static void testProfile(void *pCtx, const char *z, sqlite4_uint64 i){
  TestProfileX *p = (TestProfileX *)pCtx;
  Tcl_Obj *pScript;
  int rc;
  pScript = Tcl_DuplicateObj(p->pProfile);
  Tcl_IncrRefCount(pScript);
  Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(z, -1));
  Tcl_ListObjAppendElement(0, pScript, Tcl_NewWideIntObj(i));
  rc = Tcl_EvalObjEx(p->interp, pScript, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL);
  Tcl_DecrRefCount(pScript);
  if( rc!=TCL_OK ){
    Tcl_BackgroundError(p->interp);
  }
}
static void testProfileDel(void *pCtx){
  TestProfileX *p = (TestProfileX*)pCtx;
  int rc = Tcl_EvalObjEx(p->interp, p->pDel, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL);
  if( rc!=TCL_OK ){
    Tcl_BackgroundError(p->interp);
  }
  Tcl_DecrRefCount(p->pProfile);
  Tcl_DecrRefCount(p->pDel);
  sqlite4_free(0, (void *)p);
}
static int test_profile(
  ClientData clientData,          /* Not used */
  Tcl_Interp *interp,             /* The TCL interpreter */
  int objc,                       /* Number of arguments */
  Tcl_Obj *CONST objv[]           /* Command arguments */
){
  int nByte;                      /* Size of callback scripts in bytes */
  TestProfileX *p;                 /* New context object */
  sqlite4 *db;                    /* Database handle */

  if( objc!=4 ){
    Tcl_WrongNumArgs(interp, 1, objv, "DB PROFILE-CMD DEL-CMD");
    return TCL_ERROR;
  }
  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;

  Tcl_GetStringFromObj(objv[2], &nByte);
  if( nByte==0 ){
    sqlite4_profile(db, 0, 0, 0);
  }else{
    p = (TestProfileX*)sqlite4_malloc(0, sizeof(TestProfileX));
    p->pProfile = objv[2];
    p->pDel = objv[3];
    p->interp = interp;
    Tcl_IncrRefCount(p->pProfile);
    Tcl_IncrRefCount(p->pDel);
    sqlite4_profile(db, (void*)p, testProfile, testProfileDel);
  }

  Tcl_ResetResult(interp);
  return TCL_OK;
}
/* End of [sqlite4_profile] implementation.
********************************************************************/

/*
** Usage: sqlite4_trace DB TRACE-CMD DEL-CMD
*/
struct TestTraceX {
  Tcl_Interp *interp;
  Tcl_Obj *pTrace;
  Tcl_Obj *pDel;
};
typedef struct TestTraceX TestTraceX;
static void testTrace(void *pCtx, const char *z){
  TestTraceX *p = (TestTraceX *)pCtx;
  Tcl_Obj *pScript;
  int rc;
  pScript = Tcl_DuplicateObj(p->pTrace);
  Tcl_IncrRefCount(pScript);
  Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(z, -1));
  rc = Tcl_EvalObjEx(p->interp, pScript, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL);
  Tcl_DecrRefCount(pScript);
  if( rc!=TCL_OK ){
    Tcl_BackgroundError(p->interp);
  }
}
static void testTraceDel(void *pCtx){
  TestTraceX *p = (TestTraceX*)pCtx;
  int rc = Tcl_EvalObjEx(p->interp, p->pDel, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL);
  if( rc!=TCL_OK ){
    Tcl_BackgroundError(p->interp);
  }
  Tcl_DecrRefCount(p->pTrace);
  Tcl_DecrRefCount(p->pDel);
  sqlite4_free(0, (void *)p);
}
static int test_trace(
  ClientData clientData,          /* Not used */
  Tcl_Interp *interp,             /* The TCL interpreter */
  int objc,                       /* Number of arguments */
  Tcl_Obj *CONST objv[]           /* Command arguments */
){
  int nByte;                      /* Size of callback scripts in bytes */
  TestTraceX *p;                 /* New context object */
  sqlite4 *db;                    /* Database handle */

  if( objc!=4 ){
    Tcl_WrongNumArgs(interp, 1, objv, "DB PROFILE-CMD DEL-CMD");
    return TCL_ERROR;
  }
  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;

  Tcl_GetStringFromObj(objv[2], &nByte);
  if( nByte==0 ){
    sqlite4_trace(db, 0, 0, 0);
  }else{
    p = (TestTraceX*)sqlite4_malloc(0, sizeof(TestTraceX));
    p->pTrace = objv[2];
    p->pDel = objv[3];
    p->interp = interp;
    Tcl_IncrRefCount(p->pTrace);
    Tcl_IncrRefCount(p->pDel);
    sqlite4_trace(db, (void*)p, testTrace, testTraceDel);
  }

  Tcl_ResetResult(interp);
  return TCL_OK;
}
/* End of [sqlite4_profile] implementation.
********************************************************************/
/*
** USAGE: sqlite4_create_function_v2 DB NAME NARG ENC ?SWITCHES?
**
** Available switches are:
**
**   -func    SCRIPT
**   -step    SCRIPT

{ "sqlite4_column_database_name",test_stmt_utf8,(void*)sqlite4_column_database_name},
{ "sqlite4_column_table_name",test_stmt_utf8,(void*)sqlite4_column_table_name},
{ "sqlite4_column_origin_name",test_stmt_utf8,(void*)sqlite4_column_origin_name},
#endif

     { "sqlite4_create_collation",   test_create_collation, 0 },
     { "sqlite4_collation_needed",   test_collation_needed, 0 },
     { "sqlite4_profile",            test_profile, 0 },
     { "sqlite4_trace",              test_trace, 0 },
     { "working_64bit_int",          working_64bit_int,   0   },
     { "sqlite4_create_function_v2", test_create_function_v2, 0 },

     /* Functions from os.h */
#ifndef SQLITE4_OMIT_UTF16
     { "add_test_function",       test_function, 0           },
#endif

# 2013 Jun 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 regression tests for SQLite library.
#
# This file implements tests for the sqlite4_trace() and sqlite4_profile() 
# APIs. Specifically, it tests that destructor functions are invoked
# correctly.
#

set testdir [file dirname $argv0]
source $testdir/tester.tcl
ifcapable !trace { finish_test ; return }
set ::testprefix trace3

#-------------------------------------------------------------------------
# The following tests verify that the profile destructor is
# invoked:
#
#   1. When it is overridden, and
#   2. When the database connection is closed.
#
# It would be good to test that if an error occurs within the 
# collation_needed() the destructor is invoked immediately (as the 
# documentation says). However there is currently no way to cause
# sqlite4_collation_needed() to fail. sqlite4_collation_needed() 
# currently *always* returns SQLITE4_OK.
#

foreach {tn cmd} {
  1 sqlite4_profile
  2 sqlite4_trace
} {

  reset_db

  do_test $tn.1 {
    set ::del 0
    $cmd db abc_profile {incr ::del}
    set ::del
  } {0}

  do_test $tn.2 {
    set ::del2 0
    $cmd db def_profile {incr ::del2}
    list $::del $::del2
  } {1 0}

  do_test $tn.3 {
    db close
    list $::del $::del2
  } {1 1}
}

finish_test