SQLite

        sqlite3VdbeAddOp4Int(v,
          OP_Transaction,                    /* Opcode */
          iDb,                               /* P1 */
          DbMaskTest(pParse->writeMask,iDb), /* P2 */
          pParse->cookieValue[iDb],          /* P3 */
          db->aDb[iDb].pSchema->iGeneration  /* P4 */
        );
        if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, OPFLAG_TXNCK);
        VdbeComment((v,
              "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
      }
#ifndef SQLITE_OMIT_VIRTUALTABLE
      for(i=0; i<pParse->nVtabLock; i++){
        char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
        sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);

    return;
  }
  v = sqlite3GetVdbe(pParse);
  if( !v ) return;
  if( type!=TK_DEFERRED ){
    for(i=0; i<db->nDb; i++){
      sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
      sqlite3VdbeChangeP5(v, OPFLAG_TXNBEGIN);
      sqlite3VdbeUsesBtree(v, i);
    }
  }
  sqlite3VdbeAddOp0(v, OP_AutoCommit);
}

/*

      break;
    }
    default: {
      static const struct {
        int op;      /* The opcode */
        u32 mask;    /* Mask of the bit in sqlite3.flags to set/clear */
      } aFlagOp[] = {
        { SQLITE_DBCONFIG_ENABLE_FKEY,         SQLITE_ForeignKeys    },
        { SQLITE_DBCONFIG_ENABLE_TRIGGER,      SQLITE_EnableTrigger  },
        { SQLITE_DBCONFIG_REQUIRE_WRITE_TXN,   SQLITE_RequireWrTxn   },
      };
      unsigned int i;
      rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
      for(i=0; i<ArraySize(aFlagOp); i++){
        if( aFlagOp[i].op==op ){
          int onoff = va_arg(ap, int);
          int *pRes = va_arg(ap, int*);

#define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
#define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
#define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))
#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
#define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
#define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
#define SQLITE_READONLY_NOTXN          (SQLITE_READONLY | (5<<8))
#define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
#define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
#define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))
#define SQLITE_CONSTRAINT_FOREIGNKEY   (SQLITE_CONSTRAINT | (3<<8))
#define SQLITE_CONSTRAINT_FUNCTION     (SQLITE_CONSTRAINT | (4<<8))
#define SQLITE_CONSTRAINT_NOTNULL      (SQLITE_CONSTRAINT | (5<<8))
#define SQLITE_CONSTRAINT_PRIMARYKEY   (SQLITE_CONSTRAINT | (6<<8))

** which case the FK enforcement setting is not reported back. </dd>
**
** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
** There should be two additional arguments.
** The first argument is an integer which is 0 to disable triggers,
** positive to enable triggers or negative to leave the setting unchanged.


  The second parameter may be a NULL pointer, in
** which case the trigger setting is not reported back. </dd>
**
** <dt>SQLITE_DBCONFIG_REQUIRE_WRITE_TXN</dt>
** <dd> ^This option is used to enable or disable automatic write
** transactions. There should be two additional arguments.
** The first argument is an integer which is nonzero to disable
** automatic write transactions and zero to enable automatic write
** transactions. ^The second parameter is a pointer to an integer which if
** is not a NULL pointer is written 0 or 1 to indicate, respectively,
** whether or automatic writes transactions are enabled or disabled
** following this call. ^Automatic write transactions are enabled by default.
** ^(When automatic write transactions are enabled, any write operation
** that is not inside an explicit BEGIN ... COMMIT creates an automatic
** transaction that latests for the duration of that one write operation
** and commits or rolls back when the statement finishes.  ^(When
** automatic write transactions are disabled, attempts to write
** to the database outside of an explicit BEGIN ... COMMIT will result
** in an [SQLITE_READONLY_TXN] error.)^</dd>
**
** </dl>
*/
#define SQLITE_DBCONFIG_LOOKASIDE          1001  /* void* int int */
#define SQLITE_DBCONFIG_ENABLE_FKEY        1002  /* int int* */
#define SQLITE_DBCONFIG_ENABLE_TRIGGER     1003  /* int int* */
#define SQLITE_DBCONFIG_REQUIRE_WRITE_TXN  1004  /* int int* */


/*
** CAPI3REF: Enable Or Disable Extended Result Codes
** METHOD: sqlite3
**
** ^The sqlite3_extended_result_codes() routine enables or disables the

#define SQLITE_LoadExtension  0x00400000  /* Enable load_extension */
#define SQLITE_EnableTrigger  0x00800000  /* True to enable triggers */
#define SQLITE_DeferFKs       0x01000000  /* Defer all FK constraints */
#define SQLITE_QueryOnly      0x02000000  /* Disable database changes */
#define SQLITE_VdbeEQP        0x04000000  /* Debug EXPLAIN QUERY PLAN */
#define SQLITE_Vacuum         0x08000000  /* Currently in a VACUUM */
#define SQLITE_CellSizeCk     0x10000000  /* Check btree cell sizes on load */
#define SQLITE_RequireWrTxn   0x20000000  /* BEGIN required to write */


/*
** Bits of the sqlite3.dbOptFlags field that are used by the
** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
** selectively disable various optimizations.
*/

#define OPFLAG_BULKCSR       0x01    /* OP_Open** used to open bulk cursor */
#define OPFLAG_SEEKEQ        0x02    /* OP_Open** cursor uses EQ seek only */
#define OPFLAG_FORDELETE     0x08    /* OP_Open should use BTREE_FORDELETE */
#define OPFLAG_P2ISREG       0x10    /* P2 to OP_Open** is a register number */
#define OPFLAG_PERMUTE       0x01    /* OP_Compare: use the permutation */
#define OPFLAG_SAVEPOSITION  0x02    /* OP_Delete: keep cursor position */
#define OPFLAG_AUXDELETE     0x04    /* OP_Delete: index in a DELETE op */
#define OPFLAG_TXNCK         0x01    /* OP_Transaction: check cookie */
#define OPFLAG_TXNBEGIN      0x02    /* OP_Transaction: part of BEGIN */

/*
 * Each trigger present in the database schema is stored as an instance of
 * struct Trigger. 
 *
 * Pointers to instances of struct Trigger are stored in two ways.
 * 1. In the "trigHash" hash table (part of the sqlite3* that represents the 

    Tcl_WrongNumArgs(interp, 1, objv, "");
    return TCL_ERROR;
  }
  sqlite3_config(SQLITE_CONFIG_SQLLOG, 0, 0);
  return TCL_OK;
}
#endif

/*
** Usage:  sqlite3_db_config_flag db FLAG-VALUE ON/OFF
**
** Run one of the sqlite3_db_config(db, <flag>, int, int) interfaces.
**
** If FLAG-VALUE is negative, then make the last argument to sqlite3_db_config()
** be NULL rather than a pointer to an integer.
*/
static int test_db_config_flag(
  void * clientData,
  Tcl_Interp *interp,
  int objc,
  Tcl_Obj *CONST objv[]
){
  sqlite3 *db;
  int iFlag;
  int iNewValue;
  int iResult;
  int *piResult = &iResult;
  int rc;
  if( objc!=4 ){ 
    Tcl_WrongNumArgs(interp, 1, objv, "");
    return TCL_ERROR;
  }
  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
  if( Tcl_GetIntFromObj(interp, objv[2], &iFlag) ) return TCL_ERROR;
  if( Tcl_GetIntFromObj(interp, objv[3], &iNewValue) ) return TCL_ERROR;
  if( iFlag<0 ){
    iFlag = -iFlag;
    piResult = 0;
  }
  iResult = -99;
  rc = sqlite3_db_config(db, iFlag, iNewValue, piResult);
  if( rc ){
    Tcl_AppendResult(interp, "sqlite3_dbconfig() returned non-zero", (char*)0);
    return TCL_ERROR;
  }
  Tcl_SetObjResult(interp, Tcl_NewIntObj(iResult));
  return TCL_OK;
}

/*
** Usage: vfs_current_time_int64
**
** Return the value returned by the default VFS's xCurrentTimeInt64 method.
*/
static int vfsCurrentTimeInt64(

#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
     { "sqlite3_stmt_scanstatus",       test_stmt_scanstatus,   0 },
     { "sqlite3_stmt_scanstatus_reset", test_stmt_scanstatus_reset,   0 },
#endif
#ifdef SQLITE_ENABLE_SQLLOG
     { "sqlite3_config_sqllog",         test_config_sqllog,   0 },
#endif
     { "vfs_current_time_int64",        vfsCurrentTimeInt64,  0 },
     { "sqlite3_db_config_flag",        test_db_config_flag,  0 }, 
#ifdef SQLITE_ENABLE_SNAPSHOT
     { "sqlite3_snapshot_get", test_snapshot_get, 0 },
     { "sqlite3_snapshot_open", test_snapshot_open, 0 },
     { "sqlite3_snapshot_free", test_snapshot_free, 0 },
#endif
  };
  static int bitmask_size = sizeof(Bitmask)*8;

** More specifically, a statement transaction is opened iff the database
** connection is currently not in autocommit mode, or if there are other
** active statements. A statement transaction allows the changes made by this
** VDBE to be rolled back after an error without having to roll back the
** entire transaction. If no error is encountered, the statement transaction
** will automatically commit when the VDBE halts.
**
** If the OPFLAG_TXNCK bit (0x01) of P5 is set then this opcode also
** checks the schema cookie against P3 and the schema generation counter
** against P4.  The cookie changes its value whenever the database schema
** changes.  This operation is used to detect when that the cookie has changed
** and that the current process needs to reread the schema.  If the schema
** cookie in P3 differs from the schema cookie in the database header or
** if the schema generation counter in P4 differs from the current
** generation counter, then an SQLITE_SCHEMA error is raised and execution
** halts.  The sqlite3_step() wrapper function might then reprepare the
** statement and rerun it from the beginning.
**
** The OPFLAG_TXNBEGIN bit (0x02) of P5 is set if this opcode is part of
** the implementation of a BEGIN statement.  The OPFLAG_TXNBEGIN bit allows
** a write transaction to proceed even if the SQLITE_RequireWrTxn bit is
** set on the database connection.
*/
case OP_Transaction: {
  Btree *pBt;
  int iMeta;
  int iGen;

  assert( p->bIsReader );
  assert( p->readOnly==0 || pOp->p2==0 );
  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  assert( DbMaskTest(p->btreeMask, pOp->p1) );
  if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_RequireWrTxn))!=0 ){
    if( db->flags & SQLITE_QueryOnly ){
      rc = SQLITE_READONLY;
      goto abort_due_to_error;
    }
    if( db->autoCommit && (pOp->p5 & OPFLAG_TXNBEGIN)==0 ){
      rc = SQLITE_READONLY_NOTXN;
      goto abort_due_to_error;
    }
  }
  pBt = db->aDb[pOp->p1].pBt;

  if( pBt ){
    rc = sqlite3BtreeBeginTrans(pBt, pOp->p2);
    testcase( rc==SQLITE_BUSY_SNAPSHOT );
    testcase( rc==SQLITE_BUSY_RECOVERY );

    ** database against which the compiled query is actually executed.
    */
    sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta);
    iGen = db->aDb[pOp->p1].pSchema->iGeneration;
  }else{
    iGen = iMeta = 0;
  }
  assert( (pOp->p5 & OPFLAG_TXNCK)==0 || pOp->p4type==P4_INT32 );
  if( (pOp->p5 & OPFLAG_TXNCK)!=0 && (iMeta!=pOp->p3 || iGen!=pOp->p4.i) ){

    sqlite3VdbeError(p, "database schema has changed");
    /* If the schema-cookie from the database file matches the cookie 
    ** stored with the in-memory representation of the schema, do
    ** not reload the schema from the database file.
    **
    ** If virtual-tables are in use, this is not just an optimization.
    ** Often, v-tables store their data in other SQLite tables, which
    ** are queried from within xNext() and other v-table methods using

# 2016-02-01
#
# 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.  The
# focus of this file is testing the sqlite3_db_config() interface
#

set testdir [file dirname $argv0]
source $testdir/tester.tcl
set ::testprefix dbconfig1

do_test 100 {
  db eval {PRAGMA foreign_keys=ON;}
  sqlite3_db_config_flag db 1002 0
} {0}
do_test 101 {
  db eval {PRAGMA foreign_keys;}
} {0}
do_test 102 {
  sqlite3_db_config_flag db 1002 1
} {1}
do_test 103 {
  db eval {PRAGMA foreign_keys;}
} {1}
do_test 104 {
  sqlite3_db_config_flag db -1002 0
} {-99}

# Require explicit BEGIN...COMMIT in order to modify the database
#
sqlite3_db_config_flag db 1004 1
do_catchsql_test 200 {
  CREATE TABLE t1(x);
} {1 {attempt to write a readonly database}}
do_execsql_test 201 {
  BEGIN;
  CREATE TABLE t1(x);
  COMMIT;
  SELECT name FROM sqlite_master ORDER BY name;
} {t1}
do_execsql_test 202 {
  BEGIN IMMEDIATE;
  CREATE TABLE t2(x);
  COMMIT;
  SELECT name FROM sqlite_master ORDER BY name;
} {t1 t2}
do_execsql_test 203 {
  BEGIN EXCLUSIVE;
  CREATE TABLE t3(x);
  COMMIT;
  SELECT name FROM sqlite_master ORDER BY name;
} {t1 t2 t3}
do_execsql_test 204 {
  BEGIN;
  WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x<100)
  INSERT INTO t1(x) SELECT randomblob(500) FROM c;
  COMMIT;
  BEGIN;
  DELETE FROM t1 WHERE rowid%4!=0;
  COMMIT;
  VACUUM;
  PRAGMA integrity_check;
} {ok}

do_execsql_test 210 {
  PRAGMA journal_mode=WAL;
} {wal}
do_execsql_test 211 {
  BEGIN;
  CREATE TABLE t4(x);
  COMMIT;
  SELECT name FROM sqlite_master ORDER BY name;
} {t1 t2 t3 t4}
do_execsql_test 212 {
  BEGIN IMMEDIATE;
  CREATE TABLE t5(x);
  COMMIT;
  SELECT name FROM sqlite_master ORDER BY name;
} {t1 t2 t3 t4 t5}
do_execsql_test 213 {
  BEGIN EXCLUSIVE;
  CREATE TABLE t6(x);
  COMMIT;
  SELECT name FROM sqlite_master ORDER BY name;
} {t1 t2 t3 t4 t5 t6}
do_execsql_test 214 {
  BEGIN;
  WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x<100)
  INSERT INTO t6(x) SELECT randomblob(500) FROM c;
  COMMIT;
  BEGIN;
  DELETE FROM t6 WHERE rowid%4!=0;
  COMMIT;
  VACUUM;
  PRAGMA integrity_check;
} {ok}


finish_test