SQLite

    case SQLITE_CONFIG_COVERING_INDEX_SCAN: {
      sqlite3GlobalConfig.bUseCis = va_arg(ap, int);
      break;
    }

    case SQLITE_CONFIG_READONLY: {
      sqlite3GlobalConfig.bReadOnly = va_arg(ap, int);
      break;
    }

    default: {
      rc = SQLITE_ERROR;
      break;
    }
  }
  va_end(ap);
  return rc;
}

/*
** This API allows applications to modify the global configuration of
** the SQLite library at run-time.
**
** This routine differs from sqlite3_config() in that it may be called when
** there are outstanding database connections and/or memory allocations.
** This routine is threadsafe.
*/
int sqlite3_reconfig(int op, ...){
  va_list ap;
  int rc = SQLITE_OK;

  va_start(ap, op);
  switch( op ){
    case SQLITE_CONFIG_READONLY: {
      /*
      ** On platforms where assignment of an integer value is atomic, there
      ** is no need for a mutex here.  On other platforms, there could be a
      ** subtle race condition here; however, the effect would simply be that
      ** a call to open a database would fail with SQLITE_READONLY.
      */
      sqlite3GlobalConfig.bReadOnly = va_arg(ap, int);
      break;
    }

    default: {
      rc = SQLITE_ERROR;
      break;

int sqlite3_shutdown(void);
int sqlite3_os_init(void);
int sqlite3_os_end(void);

/*
** CAPI3REF: Configuring The SQLite Library
**
** The sqlite3_config() and sqlite3_reconfig() interfaces are used to make
** global configuration changes to SQLite in order to tune SQLite to the
** specific needs of the application.  The default configuration is recommended
** for most applications and so this routine is usually not necessary.  They
** are provided to support rare applications with unusual needs.
**
** The sqlite3_config() interface is not threadsafe.  The application
** must insure that no other SQLite interfaces are invoked by other
** threads while sqlite3_config() is running.  Furthermore, sqlite3_config()
** may only be invoked prior to library initialization using
** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()].
** ^If sqlite3_config() is called after [sqlite3_initialize()] and before
** [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
** Note, however, that ^sqlite3_config() can be called as part of the
** implementation of an application-defined [sqlite3_os_init()].
**
** The sqlite3_reconfig() interface is threadsafe and may be called at any
** time.  However, it supports only a small subset of the configuration
** options available for use with sqlite3_config().
**
** The first argument to both sqlite3_config() and sqlite3_reconfig() is an
** integer [configuration option] that determines
** what property of SQLite is to be configured.  Subsequent arguments
** vary depending on the [configuration option]
** in the first argument.
**
** ^When a configuration option is set, both sqlite3_config() and
** sqlite3_reconfig() return [SQLITE_OK].
** ^If the option is unknown or SQLite is unable to set the option
** then these routines returns a non-zero [error code].
*/
int sqlite3_config(int, ...);
int sqlite3_reconfig(int, ...);

/*
** CAPI3REF: Configure database connections
**
** The sqlite3_db_config() interface is used to make configuration
** changes to a [database connection].  The interface is similar to
** [sqlite3_config()] except that the changes apply to a single

  Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);

  return TCL_OK;
}

/*
** Usage:    sqlite3_config_readonly  BOOLEAN
**           sqlite3_reconfig_readonly  BOOLEAN
**
** Enables or disables global read-only mode using SQLITE_CONFIG_READONLY.
*/
static int test_config_readonly(
  void * clientData, 
  Tcl_Interp *interp,
  int objc,
  Tcl_Obj *CONST objv[]
){
  int rc;
  int bReadOnly;

  if( objc!=2 ){
    Tcl_WrongNumArgs(interp, 1, objv, "BOOL");
    return TCL_ERROR;
  }
  if( Tcl_GetBooleanFromObj(interp, objv[1], &bReadOnly) ){
    return TCL_ERROR;
  }

  switch( SQLITE_PTR_TO_INT(clientData) ){
    case 0: {
      rc = sqlite3_config(SQLITE_CONFIG_READONLY, bReadOnly);
      break;
    }
    case 1: {
      rc = sqlite3_reconfig(SQLITE_CONFIG_READONLY, bReadOnly);
      break;
    }
    default: {
      rc = SQLITE_ERROR;
      break;
    }
  }
  Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);

  return TCL_OK;
}

/*
** Usage:    sqlite3_dump_memsys3  FILENAME

     { "sqlite3_config_heap",        test_config_heap              ,0 },
     { "sqlite3_config_memstatus",   test_config_memstatus         ,0 },
     { "sqlite3_config_lookaside",   test_config_lookaside         ,0 },
     { "sqlite3_config_error",       test_config_error             ,0 },
     { "sqlite3_config_uri",         test_config_uri               ,0 },
     { "sqlite3_config_cis",         test_config_cis               ,0 },
     { "sqlite3_config_readonly",    test_config_readonly          ,0 },
     { "sqlite3_reconfig_readonly",  test_config_readonly          ,1 },
     { "sqlite3_db_config_lookaside",test_db_config_lookaside      ,0 },
     { "sqlite3_dump_memsys3",       test_dump_memsys3             ,3 },
     { "sqlite3_dump_memsys5",       test_dump_memsys3             ,5 },
     { "sqlite3_install_memsys3",    test_install_memsys3          ,0 },
     { "sqlite3_memdebug_vfs_oom_test", test_vfs_oom_test          ,0 },
  };
  int i;

} {1 {attempt to write a readonly database}}


# Attempt to open a database with SQLITE_OPEN_READWRITE when the
# SQLITE_CONFIG_READONLY flag is enabled.
#
db close

sqlite3_reconfig_readonly 1



do_test openv2-3.1 {
  list [catch {sqlite3 db :memory:} msg] $msg
} {1 {attempt to write a readonly database}}
catch {db close}
do_test openv2-3.2 {
  list [catch {sqlite3 db test.db} msg] $msg

} {1 {attempt to write a readonly database}}
catch {db close}
do_test openv2-3.6 {
  list [catch {sqlite3 db test.db -readonly 0} msg] $msg
} {1 {attempt to write a readonly database}}
catch {db close}


sqlite3_reconfig_readonly 0


finish_test