Merge pull request #205 from geniusgogo/sqlite

Sqlite

components/external/SQLite-3.8.1/Makefile.arm-wince-mingw32ce-gcc

+#!/usr/make
+#
+# Makefile for SQLITE
+#
+# This is a template makefile for SQLite.  Most people prefer to
+# use the autoconf generated "configure" script to generate the
+# makefile automatically.  But that does not work for everybody
+# and in every situation.  If you are having problems with the
+# "configure" script, you might want to try this makefile as an
+# alternative.  Create a copy of this file, edit the parameters
+# below and type "make".
+#
+
+#### The directory where to find the mingw32ce tools
+MINGW32CE = /opt/mingw32ce/bin
+
+#### The target prefix of the mingw32ce tools
+TARGET = arm-wince-mingw32ce
+
+#### The toplevel directory of the source tree.  This is the directory
+#    that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = ../sqlite
+
+#### C Compiler and options for use in building executables that
+#    will run on the platform that is doing the build.
+#
+BCC = gcc -g -O2
+#BCC = /opt/ancic/bin/c89 -0
+
+#### If the target operating system supports the "usleep()" system
+#    call, then define the HAVE_USLEEP macro for all C modules.
+#
+USLEEP = 
+#USLEEP = -DHAVE_USLEEP=1
+
+#### If you want the SQLite library to be safe for use within a 
+#    multi-threaded program, then define the following macro
+#    appropriately:
+#
+THREADSAFE = -DTHREADSAFE=1
+#THREADSAFE = -DTHREADSAFE=0
+
+#### Specify any extra linker options needed to make the library
+#    thread safe
+#
+#THREADLIB = -lpthread
+THREADLIB = 
+
+#### Specify any extra libraries needed to access required functions.
+#
+#TLIBS = -lrt    # fdatasync on Solaris 8
+TLIBS = 
+
+#### Leave SQLITE_DEBUG undefined for maximum speed.  Use SQLITE_DEBUG=1
+#    to check for memory leaks.  Use SQLITE_DEBUG=2 to print a log of all
+#    malloc()s and free()s in order to track down memory leaks.
+#    
+#    SQLite uses some expensive assert() statements in the inner loop.
+#    You can make the library go almost twice as fast if you compile
+#    with -DNDEBUG=1
+#
+#OPTS = -DSQLITE_DEBUG=2
+#OPTS = -DSQLITE_DEBUG=1
+#OPTS = 
+OPTS = -DNDEBUG=1 -DSQLITE_OS_WIN=1 -D_WIN32_WCE=1
+#OPTS += -DHAVE_FDATASYNC=1
+
+#### The suffix to add to executable files.  ".exe" for windows.
+#    Nothing for unix.
+#
+EXE = .exe
+#EXE =
+
+#### C Compile and options for use in building executables that 
+#    will run on the target platform.  This is usually the same
+#    as BCC, unless you are cross-compiling.
+#
+#TCC = gcc -O6
+#TCC = gcc -g -O0 -Wall
+#TCC = gcc -g -O0 -Wall -fprofile-arcs -ftest-coverage
+#TCC = /opt/mingw/bin/i386-mingw32-gcc -O6
+TCC = $(MINGW32CE)/$(TARGET)-gcc -O2
+#TCC = /opt/ansic/bin/c89 -O +z -Wl,-a,archive
+
+#### Tools used to build a static library.
+#
+#AR = ar cr
+#AR = /opt/mingw/bin/i386-mingw32-ar cr
+AR = $(MINGW32CE)/$(TARGET)-ar cr
+#RANLIB = ranlib
+#RANLIB = /opt/mingw/bin/i386-mingw32-ranlib
+RANLIB = $(MINGW32CE)/$(TARGET)-ranlib
+
+#MKSHLIB = gcc -shared
+#SO = so
+#SHPREFIX = lib
+MKSHLIB = $(MINGW32CE)/$(TARGET)-gcc -shared
+SO = dll
+SHPREFIX =
+
+#### Extra compiler options needed for programs that use the TCL library.
+#
+#TCL_FLAGS =
+#TCL_FLAGS = -DSTATIC_BUILD=1
+TCL_FLAGS = -I/home/drh/tcltk/8.5linux
+#TCL_FLAGS = -I/home/drh/tcltk/8.5win -DSTATIC_BUILD=1
+#TCL_FLAGS = -I/home/drh/tcltk/8.3hpux
+
+#### Linker options needed to link against the TCL library.
+#
+#LIBTCL = -ltcl -lm -ldl
+LIBTCL = /home/drh/tcltk/8.5linux/libtcl8.5g.a -lm -ldl
+#LIBTCL = /home/drh/tcltk/8.5win/libtcl85s.a -lmsvcrt
+#LIBTCL = /home/drh/tcltk/8.3hpux/libtcl8.3.a -ldld -lm -lc
+
+#### Additional objects for SQLite library when TCL support is enabled.
+TCLOBJ =
+#TCLOBJ = tclsqlite.o
+
+#### Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS =
+#READLINE_FLAGS = -DHAVE_READLINE=1 -I/usr/include/readline
+
+#### Linker options needed by programs using readline() must link against.
+#
+LIBREADLINE =
+#LIBREADLINE = -static -lreadline -ltermcap
+
+#### Which "awk" program provides nawk compatibilty
+#
+# NAWK = nawk
+NAWK = awk
+
+# You should not have to change anything below this line
+###############################################################################
+include $(TOP)/main.mk

components/external/SQLite-3.8.1/Makefile.linux-gcc

+#!/usr/make
+#
+# Makefile for SQLITE
+#
+# This is a template makefile for SQLite.  Most people prefer to
+# use the autoconf generated "configure" script to generate the
+# makefile automatically.  But that does not work for everybody
+# and in every situation.  If you are having problems with the
+# "configure" script, you might want to try this makefile as an
+# alternative.  Create a copy of this file, edit the parameters
+# below and type "make".
+#
+
+#### The toplevel directory of the source tree.  This is the directory
+#    that contains this "Makefile.in" and the "configure.in" script.
+#
+TOP = ../sqlite
+
+#### C Compiler and options for use in building executables that
+#    will run on the platform that is doing the build.
+#
+BCC = gcc -g -O2
+#BCC = /opt/ancic/bin/c89 -0
+
+#### If the target operating system supports the "usleep()" system
+#    call, then define the HAVE_USLEEP macro for all C modules.
+#
+#USLEEP = 
+USLEEP = -DHAVE_USLEEP=1
+
+#### If you want the SQLite library to be safe for use within a 
+#    multi-threaded program, then define the following macro
+#    appropriately:
+#
+#THREADSAFE = -DTHREADSAFE=1
+THREADSAFE = -DTHREADSAFE=0
+
+#### Specify any extra linker options needed to make the library
+#    thread safe
+#
+#THREADLIB = -lpthread
+THREADLIB = 
+
+#### Specify any extra libraries needed to access required functions.
+#
+#TLIBS = -lrt    # fdatasync on Solaris 8
+TLIBS = 
+
+#### Leave SQLITE_DEBUG undefined for maximum speed.  Use SQLITE_DEBUG=1
+#    to check for memory leaks.  Use SQLITE_DEBUG=2 to print a log of all
+#    malloc()s and free()s in order to track down memory leaks.
+#    
+#    SQLite uses some expensive assert() statements in the inner loop.
+#    You can make the library go almost twice as fast if you compile
+#    with -DNDEBUG=1
+#
+#OPTS = -DSQLITE_DEBUG=2
+#OPTS = -DSQLITE_DEBUG=1
+#OPTS = 
+OPTS = -DNDEBUG=1
+OPTS += -DHAVE_FDATASYNC=1
+
+#### The suffix to add to executable files.  ".exe" for windows.
+#    Nothing for unix.
+#
+#EXE = .exe
+EXE =
+
+#### C Compile and options for use in building executables that 
+#    will run on the target platform.  This is usually the same
+#    as BCC, unless you are cross-compiling.
+#
+TCC = gcc -O6
+#TCC = gcc -g -O0 -Wall
+#TCC = gcc -g -O0 -Wall -fprofile-arcs -ftest-coverage
+#TCC = /opt/mingw/bin/i386-mingw32-gcc -O6
+#TCC = /opt/ansic/bin/c89 -O +z -Wl,-a,archive
+
+#### Tools used to build a static library.
+#
+AR = ar cr
+#AR = /opt/mingw/bin/i386-mingw32-ar cr
+RANLIB = ranlib
+#RANLIB = /opt/mingw/bin/i386-mingw32-ranlib
+
+MKSHLIB = gcc -shared
+SO = so
+SHPREFIX = lib
+# SO = dll
+# SHPREFIX =
+
+#### Extra compiler options needed for programs that use the TCL library.
+#
+#TCL_FLAGS =
+#TCL_FLAGS = -DSTATIC_BUILD=1
+TCL_FLAGS = -I/home/drh/tcltk/8.5linux
+#TCL_FLAGS = -I/home/drh/tcltk/8.5win -DSTATIC_BUILD=1
+#TCL_FLAGS = -I/home/drh/tcltk/8.3hpux
+
+#### Linker options needed to link against the TCL library.
+#
+#LIBTCL = -ltcl -lm -ldl
+LIBTCL = /home/drh/tcltk/8.5linux/libtcl8.5g.a -lm -ldl
+#LIBTCL = /home/drh/tcltk/8.5win/libtcl85s.a -lmsvcrt
+#LIBTCL = /home/drh/tcltk/8.3hpux/libtcl8.3.a -ldld -lm -lc
+
+#### Additional objects for SQLite library when TCL support is enabled.
+#TCLOBJ =
+TCLOBJ = tclsqlite.o
+
+#### Compiler options needed for programs that use the readline() library.
+#
+READLINE_FLAGS =
+#READLINE_FLAGS = -DHAVE_READLINE=1 -I/usr/include/readline
+
+#### Linker options needed by programs using readline() must link against.
+#
+LIBREADLINE =
+#LIBREADLINE = -static -lreadline -ltermcap
+
+#### Which "awk" program provides nawk compatibilty
+#
+# NAWK = nawk
+NAWK = awk
+
+# You should not have to change anything below this line
+###############################################################################
+include $(TOP)/main.mk

components/external/SQLite-3.8.1/README

+This directory contains source code to 
+
+    SQLite: An Embeddable SQL Database Engine
+
+To compile the project, first create a directory in which to place
+the build products.  It is recommended, but not required, that the
+build directory be separate from the source directory.  Cd into the
+build directory and then from the build directory run the configure
+script found at the root of the source tree.  Then run "make".
+
+For example:
+
+    tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite"
+    mkdir bld                ;#  Build will occur in a sibling directory
+    cd bld                   ;#  Change to the build directory
+    ../sqlite/configure      ;#  Run the configure script
+    make                     ;#  Run the makefile.
+    make install             ;#  (Optional) Install the build products
+
+The configure script uses autoconf 2.61 and libtool.  If the configure
+script does not work out for you, there is a generic makefile named
+"Makefile.linux-gcc" in the top directory of the source tree that you
+can copy and edit to suit your needs.  Comments on the generic makefile
+show what changes are needed.
+
+The linux binaries on the website are created using the generic makefile,
+not the configure script.  The windows binaries on the website are created
+using MinGW32 configured as a cross-compiler running under Linux.  For 
+details, see the ./publish.sh script at the top-level of the source tree.
+The developers do not use teh configure script.
+
+SQLite does not require TCL to run, but a TCL installation is required
+by the makefiles.  SQLite contains a lot of generated code and TCL is
+used to do much of that code generation.  The makefile also requires
+AWK.
+
+Contacts:
+
+   http://www.sqlite.org/

components/external/SQLite-3.8.1/SConscript

+Import('rtconfig')
+import os
+from building import *
+
+cwd = GetCurrentDir() + str(r'/SQLiteLib/')
+src = Split("""
+SQLiteLib/sqlite3.c
+SQLiteLib/test/test10.c
+""")
+CPPPATH = [cwd, str(Dir('#'))]
+
+group = DefineGroup('sqlite', src, depend = ['RT_USING_SQLITE'], CPPPATH = CPPPATH)
+
+Return('group')

components/external/SQLite-3.8.1/SQLiteLib/README

+# SQLite on RT-Thread
+
+## 简介
+初始版本基于SQLite 3.8.1版本，使用混合单文件结构源代码
+
+测试方法：
+1.   
+    在rtconfig.h中定义一下宏,并打开newlib组件
+    /*
+    * SQLite compile macro
+    */
+    #define RT_USING_SQLITE
+    #define SQLITE_MINIMUM_FILE_DESCRIPTOR  0
+    #define SQLITE_OMIT_LOAD_EXTENSION 1 
+    #define SQLITE_OMIT_WAL 
+    #define SQLITE_RTTHREAD_NO_WIDE 1
+    #define SQLITE_ENABLE_LOCKING_STYLE 0 
+    #define SQLITE_DISABLE_LOCKING_STYLE 1
+    #define SQLITE_TEMP_STORE 1
+    #define SQLITE_THREADSAFE 1
+    #define HAVE_READLINE 0 
+    #define NDEBUG
+    #define _HAVE_SQLITE_CONFIG_H 
+    #define BUILD_sqlite
+    #define SQLITE_OS_OTHER 1 
+    #define SQLITE_OS_RTT 1
+2.
+    用test目录下的test10.c来进行测试.
+    推荐用mini2440bsp，因为板子的ram较大。
+
+注意shell.c还没有移植的。请不要使用。

components/external/SQLite-3.8.1/SQLiteLib/config.h

+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+/* #undef HAVE_DLFCN_H */
+
+/* Define to 1 if you have the `fdatasync' function. */
+/* #undef HAVE_FDATASYNC */
+
+/* Define to 1 if you have the `gmtime_r' function. */
+#define HAVE_GMTIME_R 1
+
+/* Define to 1 if the system has the type `int16_t'. */
+#define HAVE_INT16_T 1
+
+/* Define to 1 if the system has the type `int32_t'. */
+#define HAVE_INT32_T 1
+
+/* Define to 1 if the system has the type `int64_t'. */
+#define HAVE_INT64_T 1
+
+/* Define to 1 if the system has the type `int8_t'. */
+#define HAVE_INT8_T 1
+
+/* Define to 1 if the system has the type `intptr_t'. */
+#define HAVE_INTPTR_T 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `localtime_r' function. */
+#define HAVE_LOCALTIME_R 1
+
+/* Define to 1 if you have the `localtime_s' function. */
+/* #undef HAVE_LOCALTIME_S */
+
+/* Define to 1 if you have the <malloc.h> header file. */
+/* #define HAVE_MALLOC_H 0 */
+
+/* Define to 1 if you have the `malloc_usable_size' function. */
+/* #define HAVE_MALLOC_USABLE_SIZE 0 */
+
+/* Define to 1 if you have the <memory.h> header file. */
+/* #undef HAVE_MEMORY_H */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+/* #undef HAVE_STRINGS_H */
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if the system has the type `uint16_t'. */
+#define HAVE_UINT16_T 1
+
+/* Define to 1 if the system has the type `uint32_t'. */
+#define HAVE_UINT32_T 1
+
+/* Define to 1 if the system has the type `uint64_t'. */
+#define HAVE_UINT64_T 1
+
+/* Define to 1 if the system has the type `uint8_t'. */
+#define HAVE_UINT8_T 1
+
+/* Define to 1 if the system has the type `uintptr_t'. */
+#define HAVE_UINTPTR_T 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `usleep' function. */
+/* #undef HAVE_USLEEP */
+
+/* Define to 1 if you have the utime() library function. */
+/* #undef HAVE_UTIME */
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#define LT_OBJDIR ".libs/"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "sqlite"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "sqlite 3.8.1"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "sqlite"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "3.8.1"
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */

components/external/SQLite-3.8.1/SQLiteLib/test/test10.c

+#include <stdio.h>
+#include <sqlite3.h>
+#include "finsh.h"
+
+static int callback(void *NotUsed, int argc, char **argv, char **azColName){
+  int i;
+  for(i=0; i<argc; i++){
+    rt_kprintf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
+  }
+  rt_kprintf("\n");
+  return 0;
+}
+
+int test10_main(void){
+  static int step = 0;
+  int argc = 4;
+  char *argv[4] = {"test10_main", "test.db", 
+            "create table mytable(entry1 int)",
+            "drop table mytable"};
+  sqlite3 *db;
+  char *zErrMsg = 0;
+  int rc;
+
+  if( argc<3 ){
+    rt_kprintf("Usage: %s DATABASE SQL-STATEMENT\n", argv[0]);
+    return(1);
+  }
+  rt_kprintf("ready open %s\n", argv[1]);
+  rc = sqlite3_open(argv[1], &db);
+
+  if( rc ){
+    rt_kprintf("Can't open database: %s\n", sqlite3_errmsg(db));
+    sqlite3_close(db);
+    return(1);
+  }
+  else{
+    rt_kprintf("open %s success\n", argv[1]);
+  }
+
+  if (step == 0) {
+      rt_kprintf("SQL exec: %s\n", argv[2]);
+      rc = sqlite3_exec(db, argv[2], callback, 0, &zErrMsg);
+      if( rc!=SQLITE_OK ){
+        rt_kprintf("SQL error: %s\n", zErrMsg);
+        sqlite3_free(zErrMsg);
+      }
+      else{
+        rt_kprintf("SQL exec: %s success\n", argv[2]);
+      }
+  }
+  else {
+      rt_kprintf("SQL exec: %s\n", argv[3]);
+      rc = sqlite3_exec(db, argv[3], callback, 0, &zErrMsg);
+      if( rc!=SQLITE_OK ){
+        rt_kprintf("SQL error: %s\n", zErrMsg);
+        sqlite3_free(zErrMsg);
+      }
+      else{
+        rt_kprintf("SQL exec: %s success\n", argv[3]);
+      }
+  }
+
+  step = !step;
+  
+  sqlite3_close(db);
+  return 0;
+}
+FINSH_FUNCTION_EXPORT(test10_main, sqlite test)
\ No newline at end of file

components/external/SQLite-3.8.1/SQLiteLib/test/test2.c

+/*
+** 2001 September 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.
+**
+*************************************************************************
+** Code for testing the pager.c module in SQLite.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+*/
+#include "sqliteInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+extern const char *sqlite3ErrName(int);
+
+/*
+** Page size and reserved size used for testing.
+*/
+static int test_pagesize = 1024;
+
+/*
+** Dummy page reinitializer
+*/
+static void pager_test_reiniter(DbPage *pNotUsed){
+  return;
+}
+
+/*
+** Usage:   pager_open FILENAME N-PAGE
+**
+** Open a new pager
+*/
+static int pager_open(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  u32 pageSize;
+  Pager *pPager;
+  int nPage;
+  int rc;
+  char zBuf[100];
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " FILENAME N-PAGE\"", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[2], &nPage) ) return TCL_ERROR;
+  rc = sqlite3PagerOpen(sqlite3_vfs_find(0), &pPager, argv[1], 0, 0,
+      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB,
+      pager_test_reiniter);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3PagerSetCachesize(pPager, nPage);
+  pageSize = test_pagesize;
+  sqlite3PagerSetPagesize(pPager, &pageSize, -1);
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPager);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_close ID
+**
+** Close the given pager.
+*/
+static int pager_close(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  rc = sqlite3PagerClose(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_rollback ID
+**
+** Rollback changes
+*/
+static int pager_rollback(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  rc = sqlite3PagerRollback(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_commit ID
+**
+** Commit all changes
+*/
+static int pager_commit(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  rc = sqlite3PagerCommitPhaseOne(pPager, 0, 0);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  rc = sqlite3PagerCommitPhaseTwo(pPager);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_stmt_begin ID
+**
+** Start a new checkpoint.
+*/
+static int pager_stmt_begin(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  rc = sqlite3PagerOpenSavepoint(pPager, 1);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_stmt_rollback ID
+**
+** Rollback changes to a checkpoint
+*/
+static int pager_stmt_rollback(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, 0);
+  sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_stmt_commit ID
+**
+** Commit changes to a checkpoint
+*/
+static int pager_stmt_commit(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_stats ID
+**
+** Return pager statistics.
+*/
+static int pager_stats(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int i, *a;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  a = sqlite3PagerStats(pPager);
+  for(i=0; i<9; i++){
+    static char *zName[] = {
+      "ref", "page", "max", "size", "state", "err",
+      "hit", "miss", "ovfl",
+    };
+    char zBuf[100];
+    Tcl_AppendElement(interp, zName[i]);
+    sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",a[i]);
+    Tcl_AppendElement(interp, zBuf);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_pagecount ID
+**
+** Return the size of the database file.
+*/
+static int pager_pagecount(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  char zBuf[100];
+  int nPage;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  sqlite3PagerPagecount(pPager, &nPage);
+  sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", nPage);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_get ID PGNO
+**
+** Return a pointer to a page from the database.
+*/
+static int page_get(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  char zBuf[100];
+  DbPage *pPage;
+  int pgno;
+  int rc;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID PGNO\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
+  rc = sqlite3PagerSharedLock(pPager);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3PagerGet(pPager, pgno, &pPage);
+  }
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_lookup ID PGNO
+**
+** Return a pointer to a page if the page is already in cache.
+** If not in cache, return an empty string.
+*/
+static int page_lookup(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  char zBuf[100];
+  DbPage *pPage;
+  int pgno;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID PGNO\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
+  pPage = sqlite3PagerLookup(pPager, pgno);
+  if( pPage ){
+    sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
+    Tcl_AppendResult(interp, zBuf, 0);
+  }
+  return TCL_OK;
+}
+
+/*
+** Usage:   pager_truncate ID PGNO
+*/
+static int pager_truncate(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  Pager *pPager;
+  int pgno;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID PGNO\"", 0);
+    return TCL_ERROR;
+  }
+  pPager = sqlite3TestTextToPtr(argv[1]);
+  if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR;
+  sqlite3PagerTruncateImage(pPager, pgno);
+  return TCL_OK;
+}
+
+
+/*
+** Usage:   page_unref PAGE
+**
+** Drop a pointer to a page.
+*/
+static int page_unref(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  DbPage *pPage;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " PAGE\"", 0);
+    return TCL_ERROR;
+  }
+  pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
+  sqlite3PagerUnref(pPage);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_read PAGE
+**
+** Return the content of a page
+*/
+static int page_read(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  char zBuf[100];
+  DbPage *pPage;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " PAGE\"", 0);
+    return TCL_ERROR;
+  }
+  pPage = sqlite3TestTextToPtr(argv[1]);
+  memcpy(zBuf, sqlite3PagerGetData(pPage), sizeof(zBuf));
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_number PAGE
+**
+** Return the page number for a page.
+*/
+static int page_number(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  char zBuf[100];
+  DbPage *pPage;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " PAGE\"", 0);
+    return TCL_ERROR;
+  }
+  pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
+  sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3PagerPagenumber(pPage));
+  Tcl_AppendResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage:   page_write PAGE DATA
+**
+** Write something into a page.
+*/
+static int page_write(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  DbPage *pPage;
+  char *pData;
+  int rc;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " PAGE DATA\"", 0);
+    return TCL_ERROR;
+  }
+  pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
+  rc = sqlite3PagerWrite(pPage);
+  if( rc!=SQLITE_OK ){
+    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  pData = sqlite3PagerGetData(pPage);
+  strncpy(pData, argv[2], test_pagesize-1);
+  pData[test_pagesize-1] = 0;
+  return TCL_OK;
+}
+
+#ifndef SQLITE_OMIT_DISKIO
+/*
+** Usage:   fake_big_file  N  FILENAME
+**
+** Write a few bytes at the N megabyte point of FILENAME.  This will
+** create a large file.  If the file was a valid SQLite database, then
+** the next time the database is opened, SQLite will begin allocating
+** new pages after N.  If N is 2096 or bigger, this will test the
+** ability of SQLite to write to large files.
+*/
+static int fake_big_file(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  sqlite3_vfs *pVfs;
+  sqlite3_file *fd = 0;
+  int rc;
+  int n;
+  i64 offset;
+  char *zFile;
+  int nFile;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " N-MEGABYTES FILE\"", 0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
+
+  pVfs = sqlite3_vfs_find(0);
+  nFile = (int)strlen(argv[2]);
+  zFile = sqlite3_malloc( nFile+2 );
+  if( zFile==0 ) return TCL_ERROR;
+  memcpy(zFile, argv[2], nFile+1);
+  zFile[nFile+1] = 0;
+  rc = sqlite3OsOpenMalloc(pVfs, zFile, &fd, 
+      (SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB), 0
+  );
+  if( rc ){
+    Tcl_AppendResult(interp, "open failed: ", sqlite3ErrName(rc), 0);
+    sqlite3_free(zFile);
+    return TCL_ERROR;
+  }
+  offset = n;
+  offset *= 1024*1024;
+  rc = sqlite3OsWrite(fd, "Hello, World!", 14, offset);
+  sqlite3OsCloseFree(fd);
+  sqlite3_free(zFile);
+  if( rc ){
+    Tcl_AppendResult(interp, "write failed: ", sqlite3ErrName(rc), 0);
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+#endif
+
+
+/*
+** test_control_pending_byte  PENDING_BYTE
+**
+** Set the PENDING_BYTE using the sqlite3_test_control() interface.
+*/
+static int testPendingByte(
+  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 pbyte;
+  int rc;
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+                     " PENDING-BYTE\"", (void*)0);
+    return TCL_ERROR;
+  }
+  if( Tcl_GetInt(interp, argv[1], &pbyte) ) return TCL_ERROR;
+  rc = sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, pbyte);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
+  return TCL_OK;
+}  
+
+/*
+** sqlite3BitvecBuiltinTest SIZE PROGRAM
+**
+** Invoke the SQLITE_TESTCTRL_BITVEC_TEST operator on test_control.
+** See comments on sqlite3BitvecBuiltinTest() for additional information.
+*/
+static int testBitvecBuiltinTest(
+  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 sz, rc;
+  int nProg = 0;
+  int aProg[100];
+  const char *z;
+  if( argc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+                     " SIZE PROGRAM\"", (void*)0);
+  }
+  if( Tcl_GetInt(interp, argv[1], &sz) ) return TCL_ERROR;
+  z = argv[2];
+  while( nProg<99 && *z ){
+    while( *z && !sqlite3Isdigit(*z) ){ z++; }
+    if( *z==0 ) break;
+    aProg[nProg++] = atoi(z);
+    while( sqlite3Isdigit(*z) ){ z++; }
+  }
+  aProg[nProg] = 0;
+  rc = sqlite3_test_control(SQLITE_TESTCTRL_BITVEC_TEST, sz, aProg);
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
+  return TCL_OK;
+}  
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest2_Init(Tcl_Interp *interp){
+  extern int sqlite3_io_error_persist;
+  extern int sqlite3_io_error_pending;
+  extern int sqlite3_io_error_hit;
+  extern int sqlite3_io_error_hardhit;
+  extern int sqlite3_diskfull_pending;
+  extern int sqlite3_diskfull;
+  static struct {
+    char *zName;
+    Tcl_CmdProc *xProc;
+  } aCmd[] = {
+    { "pager_open",              (Tcl_CmdProc*)pager_open          },
+    { "pager_close",             (Tcl_CmdProc*)pager_close         },
+    { "pager_commit",            (Tcl_CmdProc*)pager_commit        },
+    { "pager_rollback",          (Tcl_CmdProc*)pager_rollback      },
+    { "pager_stmt_begin",        (Tcl_CmdProc*)pager_stmt_begin    },
+    { "pager_stmt_commit",       (Tcl_CmdProc*)pager_stmt_commit   },
+    { "pager_stmt_rollback",     (Tcl_CmdProc*)pager_stmt_rollback },
+    { "pager_stats",             (Tcl_CmdProc*)pager_stats         },
+    { "pager_pagecount",         (Tcl_CmdProc*)pager_pagecount     },
+    { "page_get",                (Tcl_CmdProc*)page_get            },
+    { "page_lookup",             (Tcl_CmdProc*)page_lookup         },
+    { "page_unref",              (Tcl_CmdProc*)page_unref          },
+    { "page_read",               (Tcl_CmdProc*)page_read           },
+    { "page_write",              (Tcl_CmdProc*)page_write          },
+    { "page_number",             (Tcl_CmdProc*)page_number         },
+    { "pager_truncate",          (Tcl_CmdProc*)pager_truncate      },
+#ifndef SQLITE_OMIT_DISKIO
+    { "fake_big_file",           (Tcl_CmdProc*)fake_big_file       },
+#endif
+    { "sqlite3BitvecBuiltinTest",(Tcl_CmdProc*)testBitvecBuiltinTest     },
+    { "sqlite3_test_control_pending_byte", (Tcl_CmdProc*)testPendingByte },
+  };
+  int i;
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+    Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
+  }
+  Tcl_LinkVar(interp, "sqlite_io_error_pending",
+     (char*)&sqlite3_io_error_pending, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_io_error_persist",
+     (char*)&sqlite3_io_error_persist, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_io_error_hit",
+     (char*)&sqlite3_io_error_hit, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_io_error_hardhit",
+     (char*)&sqlite3_io_error_hardhit, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_diskfull_pending",
+     (char*)&sqlite3_diskfull_pending, TCL_LINK_INT);
+  Tcl_LinkVar(interp, "sqlite_diskfull",
+     (char*)&sqlite3_diskfull, TCL_LINK_INT);
+#ifndef SQLITE_OMIT_WSD
+  Tcl_LinkVar(interp, "sqlite_pending_byte",
+     (char*)&sqlite3PendingByte, TCL_LINK_INT | TCL_LINK_READ_ONLY);
+#endif
+  return TCL_OK;
+}

components/external/SQLite-3.8.1/SQLiteLib/test/test5.c

+/*
+** 2001 September 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.
+**
+*************************************************************************
+** Code for testing the utf.c module in SQLite.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library. Specifically, the code in this file
+** is used for testing the SQLite routines for converting between
+** the various supported unicode encodings.
+*/
+#include "sqliteInt.h"
+#include "vdbeInt.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*
+** The first argument is a TCL UTF-8 string. Return the byte array
+** object with the encoded representation of the string, including
+** the NULL terminator.
+*/
+static int binarize(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int len;
+  char *bytes;
+  Tcl_Obj *pRet;
+  assert(objc==2);
+
+  bytes = Tcl_GetStringFromObj(objv[1], &len);
+  pRet = Tcl_NewByteArrayObj((u8*)bytes, len+1);
+  Tcl_SetObjResult(interp, pRet);
+  return TCL_OK;
+}
+
+/*
+** Usage: test_value_overhead <repeat-count> <do-calls>.
+**
+** This routine is used to test the overhead of calls to
+** sqlite3_value_text(), on a value that contains a UTF-8 string. The idea
+** is to figure out whether or not it is a problem to use sqlite3_value
+** structures with collation sequence functions.
+**
+** If <do-calls> is 0, then the calls to sqlite3_value_text() are not
+** actually made.
+*/
+static int test_value_overhead(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  int do_calls;
+  int repeat_count;
+  int i;
+  Mem val;
+
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), " <repeat-count> <do-calls>", 0);
+    return TCL_ERROR;
+  }
+
+  if( Tcl_GetIntFromObj(interp, objv[1], &repeat_count) ) return TCL_ERROR;
+  if( Tcl_GetIntFromObj(interp, objv[2], &do_calls) ) return TCL_ERROR;
+
+  val.flags = MEM_Str|MEM_Term|MEM_Static;
+  val.z = "hello world";
+  val.type = SQLITE_TEXT;
+  val.enc = SQLITE_UTF8;
+
+  for(i=0; i<repeat_count; i++){
+    if( do_calls ){
+      sqlite3_value_text(&val);
+    }
+  }
+
+  return TCL_OK;
+}
+
+static u8 name_to_enc(Tcl_Interp *interp, Tcl_Obj *pObj){
+  struct EncName {
+    char *zName;
+    u8 enc;
+  } encnames[] = {
+    { "UTF8", SQLITE_UTF8 },
+    { "UTF16LE", SQLITE_UTF16LE },
+    { "UTF16BE", SQLITE_UTF16BE },
+    { "UTF16", SQLITE_UTF16 },
+    { 0, 0 }
+  };
+  struct EncName *pEnc;
+  char *z = Tcl_GetString(pObj);
+  for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
+    if( 0==sqlite3StrICmp(z, pEnc->zName) ){
+      break;
+    }
+  }
+  if( !pEnc->enc ){
+    Tcl_AppendResult(interp, "No such encoding: ", z, 0);
+  }
+  if( pEnc->enc==SQLITE_UTF16 ){
+    return SQLITE_UTF16NATIVE;
+  }
+  return pEnc->enc;
+}
+
+/*
+** Usage:   test_translate <string/blob> <from enc> <to enc> ?<transient>?
+**
+*/
+static int test_translate(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  u8 enc_from;
+  u8 enc_to;
+  sqlite3_value *pVal;
+
+  char *z;
+  int len;
+  void (*xDel)(void *p) = SQLITE_STATIC;
+
+  if( objc!=4 && objc!=5 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+        Tcl_GetStringFromObj(objv[0], 0), 
+        " <string/blob> <from enc> <to enc>", 0
+    );
+    return TCL_ERROR;
+  }
+  if( objc==5 ){
+    xDel = sqlite3_free;
+  }
+
+  enc_from = name_to_enc(interp, objv[2]);
+  if( !enc_from ) return TCL_ERROR;
+  enc_to = name_to_enc(interp, objv[3]);
+  if( !enc_to ) return TCL_ERROR;
+
+  pVal = sqlite3ValueNew(0);
+
+  if( enc_from==SQLITE_UTF8 ){
+    z = Tcl_GetString(objv[1]);
+    if( objc==5 ){
+      z = sqlite3_mprintf("%s", z);
+    }
+    sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);
+  }else{
+    z = (char*)Tcl_GetByteArrayFromObj(objv[1], &len);
+    if( objc==5 ){
+      char *zTmp = z;
+      z = sqlite3_malloc(len);
+      memcpy(z, zTmp, len);
+    }
+    sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);
+  }
+
+  z = (char *)sqlite3ValueText(pVal, enc_to);
+  len = sqlite3ValueBytes(pVal, enc_to) + (enc_to==SQLITE_UTF8?1:2);
+  Tcl_SetObjResult(interp, Tcl_NewByteArrayObj((u8*)z, len));
+
+  sqlite3ValueFree(pVal);
+
+  return TCL_OK;
+}
+
+/*
+** Usage: translate_selftest
+**
+** Call sqlite3UtfSelfTest() to run the internal tests for unicode
+** translation. If there is a problem an assert() will fail.
+**/
+void sqlite3UtfSelfTest(void);
+static int test_translate_selftest(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_UTF16
+  sqlite3UtfSelfTest();
+#endif
+  return SQLITE_OK;
+}
+
+
+/*
+** Register commands with the TCL interpreter.
+*/
+int Sqlitetest5_Init(Tcl_Interp *interp){
+  static struct {
+    char *zName;
+    Tcl_ObjCmdProc *xProc;
+  } aCmd[] = {
+    { "binarize",                (Tcl_ObjCmdProc*)binarize },
+    { "test_value_overhead",     (Tcl_ObjCmdProc*)test_value_overhead },
+    { "test_translate",          (Tcl_ObjCmdProc*)test_translate     },
+    { "translate_selftest",      (Tcl_ObjCmdProc*)test_translate_selftest},
+  };
+  int i;
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+    Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
+  }
+  return SQLITE_OK;
+}

components/external/SQLite-3.8.1/SQLiteLib/test/test_btree.c

+/*
+** 2007 May 05
+**
+** 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.
+**
+*************************************************************************
+** Code for testing the btree.c module in SQLite.  This code
+** is not included in the SQLite library.  It is used for automated
+** testing of the SQLite library.
+*/
+#include "btreeInt.h"
+#include <tcl.h>
+
+/*
+** Usage: sqlite3_shared_cache_report
+**
+** Return a list of file that are shared and the number of
+** references to each file.
+*/
+int sqlite3BtreeSharedCacheReport(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+#ifndef SQLITE_OMIT_SHARED_CACHE
+  extern BtShared *sqlite3SharedCacheList;
+  BtShared *pBt;
+  Tcl_Obj *pRet = Tcl_NewObj();
+  for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
+    const char *zFile = sqlite3PagerFilename(pBt->pPager, 1);
+    Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(zFile, -1));
+    Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(pBt->nRef));
+  }
+  Tcl_SetObjResult(interp, pRet);
+#endif
+  return TCL_OK;
+}
+
+/*
+** Print debugging information about all cursors to standard output.
+*/
+void sqlite3BtreeCursorList(Btree *p){
+#ifdef SQLITE_DEBUG
+  BtCursor *pCur;
+  BtShared *pBt = p->pBt;
+  for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
+    MemPage *pPage = pCur->apPage[pCur->iPage];
+    char *zMode = pCur->wrFlag ? "rw" : "ro";
+    sqlite3DebugPrintf("CURSOR %p rooted at %4d(%s) currently at %d.%d%s\n",
+       pCur, pCur->pgnoRoot, zMode,
+       pPage ? pPage->pgno : 0, pCur->aiIdx[pCur->iPage],
+       (pCur->eState==CURSOR_VALID) ? "" : " eof"
+    );
+  }
+#endif
+}

components/external/SQLite-3.8.1/VERSION

+3.8.1

components/external/SQLite-3.8.1/ext/README.txt

+Version loadable extensions to SQLite are found in subfolders
+of this folder.