rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/sqlite3/SqliteWrapper/sqliteLimit_h.cs

@@ -0,0 +1,214 @@
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2007 May 7
+    **
+    ** 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 defines various limits of what SQLite can process.
+    *************************************************************************
+    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
+    **  C#-SQLite is an independent reimplementation of the SQLite software library
+    **
+    **  SQLITE_SOURCE_ID: 2009-12-07 16:39:13 1ed88e9d01e9eda5cbc622e7614277f29bcc551c
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    /*
+    ** The maximum length of a TEXT or BLOB in bytes.   This also
+    ** limits the size of a row in a table or index.
+    **
+    ** The hard limit is the ability of a 32-bit signed integer
+    ** to count the size: 2^31-1 or 2147483647.
+    */
+#if !SQLITE_MAX_LENGTH
+    const int SQLITE_MAX_LENGTH = 1000000000;
+#endif
+
+    /*
+** This is the maximum number of
+**
+**    * Columns in a table
+**    * Columns in an index
+**    * Columns in a view
+**    * Terms in the SET clause of an UPDATE statement
+**    * Terms in the result set of a SELECT statement
+**    * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.
+**    * Terms in the VALUES clause of an INSERT statement
+**
+** The hard upper limit here is 32676.  Most database people will
+** tell you that in a well-normalized database, you usually should
+** not have more than a dozen or so columns in any table.  And if
+** that is the case, there is no point in having more than a few
+** dozen values in any of the other situations described above.
+*/
+#if !SQLITE_MAX_COLUMN
+    const int SQLITE_MAX_COLUMN = 2000;
+#endif
+
+    /*
+** The maximum length of a single SQL statement in bytes.
+**
+** It used to be the case that setting this value to zero would
+** turn the limit off.  That is no longer true.  It is not possible
+** to turn this limit off.
+*/
+#if !SQLITE_MAX_SQL_LENGTH
+    const int SQLITE_MAX_SQL_LENGTH = 1000000000;
+#endif
+
+    /*
+** The maximum depth of an expression tree. This is limited to
+** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might
+** want to place more severe limits on the complexity of an
+** expression.
+**
+** A value of 0 used to mean that the limit was not enforced.
+** But that is no longer true.  The limit is now strictly enforced
+** at all times.
+*/
+#if !SQLITE_MAX_EXPR_DEPTH
+    const int SQLITE_MAX_EXPR_DEPTH = 1000;
+#endif
+
+    /*
+** The maximum number of terms in a compound SELECT statement.
+** The code generator for compound SELECT statements does one
+** level of recursion for each term.  A stack overflow can result
+** if the number of terms is too large.  In practice, most SQL
+** never has more than 3 or 4 terms.  Use a value of 0 to disable
+** any limit on the number of terms in a compount SELECT.
+*/
+#if !SQLITE_MAX_COMPOUND_SELECT
+    const int SQLITE_MAX_COMPOUND_SELECT = 250;
+#endif
+
+    /*
+** The maximum number of opcodes in a VDBE program.
+** Not currently enforced.
+*/
+#if !SQLITE_MAX_VDBE_OP
+    const int SQLITE_MAX_VDBE_OP = 25000;
+#endif
+
+    /*
+** The maximum number of arguments to an SQL function.
+*/
+#if !SQLITE_MAX_FUNCTION_ARG
+    const int SQLITE_MAX_FUNCTION_ARG = 127;//# define SQLITE_MAX_FUNCTION_ARG 127
+#endif
+
+    /*
+** The maximum number of in-memory pages to use for the main database
+** table and for temporary tables.  The SQLITE_DEFAULT_CACHE_SIZE
+*/
+#if !SQLITE_DEFAULT_CACHE_SIZE
+    const int SQLITE_DEFAULT_CACHE_SIZE = 2000;
+#endif
+#if !SQLITE_DEFAULT_TEMP_CACHE_SIZE
+    const int SQLITE_DEFAULT_TEMP_CACHE_SIZE = 500;
+#endif
+
+    /*
+** The maximum number of attached databases.  This must be between 0
+** and 30.  The upper bound on 30 is because a 32-bit integer bitmap
+** is used internally to track attached databases.
+*/
+#if !SQLITE_MAX_ATTACHED
+    const int SQLITE_MAX_ATTACHED = 10;
+#endif
+
+
+    /*
+** The maximum value of a ?nnn wildcard that the parser will accept.
+*/
+#if !SQLITE_MAX_VARIABLE_NUMBER
+    const int SQLITE_MAX_VARIABLE_NUMBER = 999;
+#endif
+
+    /* Maximum page size.  The upper bound on this value is 32768.  This a limit
+** imposed by the necessity of storing the value in a 2-byte unsigned integer
+** and the fact that the page size must be a power of 2.
+**
+** If this limit is changed, then the compiled library is technically
+** incompatible with an SQLite library compiled with a different limit. If
+** a process operating on a database with a page-size of 65536 bytes
+** crashes, then an instance of SQLite compiled with the default page-size
+** limit will not be able to rollback the aborted transaction. This could
+** lead to database corruption.
+*/
+#if !SQLITE_MAX_PAGE_SIZE
+    const int SQLITE_MAX_PAGE_SIZE = 32768;
+#endif
+
+
+    /*
+** The default size of a database page.
+*/
+#if !SQLITE_DEFAULT_PAGE_SIZE
+    const int SQLITE_DEFAULT_PAGE_SIZE = 1024;
+#endif
+#if SQLITE_DEFAULT_PAGE_SIZE //SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
+//# undef SQLITE_DEFAULT_PAGE_SIZE
+const int SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
+#endif
+
+    /*
+** Ordinarily, if no value is explicitly provided, SQLite creates databases
+** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain
+** device characteristics (sector-size and atomic write() support),
+** SQLite may choose a larger value. This constant is the maximum value
+** SQLite will choose on its own.
+*/
+#if !SQLITE_MAX_DEFAULT_PAGE_SIZE
+    const int SQLITE_MAX_DEFAULT_PAGE_SIZE = 8192;
+#endif
+#if SQLITE_MAX_DEFAULT_PAGE_SIZE //SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
+//# undef SQLITE_MAX_DEFAULT_PAGE_SIZE
+const int SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
+#endif
+
+
+    /*
+** Maximum number of pages in one database file.
+**
+** This is really just the default value for the max_page_count pragma.
+** This value can be lowered (or raised) at run-time using that the
+** max_page_count macro.
+*/
+#if !SQLITE_MAX_PAGE_COUNT
+    const int SQLITE_MAX_PAGE_COUNT = 1073741823;
+#endif
+
+    /*
+** Maximum length (in bytes) of the pattern in a LIKE or GLOB
+** operator.
+*/
+    //#if !SQLITE_MAX_LIKE_PATTERN_LENGTH
+    const int SQLITE_MAX_LIKE_PATTERN_LENGTH = 50000;
+    //#endif
+
+    /*
+    ** Maximum depth of recursion for triggers.
+    **
+    ** A value of 1 means that a trigger program will not be able to itself
+    ** fire any triggers. A value of 0 means that no trigger programs at all 
+    ** may be executed.
+    */
+#if !SQLITE_MAX_TRIGGER_DEPTH
+    const int SQLITE_MAX_TRIGGER_DEPTH = 1000;  // # define SQLITE_MAX_TRIGGER_DEPTH 1000
+#else
+  const int SQLITE_MAX_TRIGGER_DEPTH=1;
+#endif
+  }
+}

data/platform/wp7/sqlite3/SqliteWrapper/sqliteicu_h.cs

@@ -0,0 +1,39 @@
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2008 May 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.
+    **
+    ******************************************************************************
+    **
+    ** This header file is used by programs that want to link against the
+    ** ICU extension.  All it does is declare the sqlite3IcuInit() interface.
+    **
+    *************************************************************************
+    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
+    **  C#-SQLite is an independent reimplementation of the SQLite software library
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqlite3.h"
+
+    //#if __cplusplus
+    //extern "C" {
+    //#endif  /* __cplusplus */
+
+    //int sqlite3IcuInit(sqlite3 *db);
+
+    //#if __cplusplus
+    //}  /* extern "C" */
+    //#endif  /* __cplusplus */
+  }
+}

data/platform/wp7/sqlite3/SqliteWrapper/status_c.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+
+namespace Community.CsharpSqlite
+{
+  using sqlite3_value = Sqlite3.Mem;
+
+  public partial class Sqlite3
+  {
+    /*
+    ** 2008 June 18
+    **
+    ** 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 module implements the sqlite3_status() interface and related
+    ** functionality.
+    *************************************************************************
+    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
+    **  C#-SQLite is an independent reimplementation of the SQLite software library
+    **
+    **  SQLITE_SOURCE_ID: 2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+
+    /*
+    ** Variables in which to record status information.
+    */
+    //typedef struct sqlite3StatType sqlite3StatType;
+    public class sqlite3StatType
+    {
+      public int[] nowValue = new int[9];        /* Current value */
+      public int[] mxValue = new int[9];           /* Maximum value */
+    }
+    public static sqlite3StatType sqlite3Stat = new sqlite3StatType();
+
+    /* The "wsdStat" macro will resolve to the status information
+    ** state vector.  If writable static data is unsupported on the target,
+    ** we have to locate the state vector at run-time.  In the more common
+    ** case where writable static data is supported, wsdStat can refer directly
+    ** to the "sqlite3Stat" state vector declared above.
+    */
+#if SQLITE_OMIT_WSD
+//# define wsdStatInit  sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat)
+//# define wsdStat x[0]
+#else
+    //# define wsdStatInit
+    static void wsdStatInit() { }
+    //# define wsdStat sqlite3Stat
+    static sqlite3StatType wsdStat = sqlite3Stat;
+#endif
+
+    /*
+** Return the current value of a status parameter.
+*/
+    static int sqlite3StatusValue( int op )
+    {
+      wsdStatInit();
+      Debug.Assert( op >= 0 && op < ArraySize( wsdStat.nowValue ) );
+      return wsdStat.nowValue[op];
+    }
+
+    /*
+    ** Add N to the value of a status record.  It is assumed that the
+    ** caller holds appropriate locks.
+    */
+    static void sqlite3StatusAdd( int op, int N )
+    {
+      wsdStatInit();
+      Debug.Assert( op >= 0 && op < ArraySize( wsdStat.nowValue ) );
+      wsdStat.nowValue[op] += N;
+      if ( wsdStat.nowValue[op] > wsdStat.mxValue[op] )
+      {
+        wsdStat.mxValue[op] = wsdStat.nowValue[op];
+      }
+    }
+
+    /*
+    ** Set the value of a status to X.
+    */
+    static void sqlite3StatusSet( int op, int X )
+    {
+      wsdStatInit();
+      Debug.Assert( op >= 0 && op < ArraySize( wsdStat.nowValue ) );
+      wsdStat.nowValue[op] = X;
+      if ( wsdStat.nowValue[op] > wsdStat.mxValue[op] )
+      {
+        wsdStat.mxValue[op] = wsdStat.nowValue[op];
+      }
+    }
+
+    /*
+    ** Query status information.
+    **
+    ** This implementation assumes that reading or writing an aligned
+    ** 32-bit integer is an atomic operation.  If that assumption is not true,
+    ** then this routine is not threadsafe.
+    */
+    static int sqlite3_status( int op, ref int pCurrent, ref int pHighwater, int resetFlag )
+    {
+      wsdStatInit();
+      if ( op < 0 || op >= ArraySize( wsdStat.nowValue ) )
+      {
+        return SQLITE_MISUSE_BKPT();
+      }
+      pCurrent = wsdStat.nowValue[op];
+      pHighwater = wsdStat.mxValue[op];
+      if ( resetFlag != 0 )
+      {
+        wsdStat.mxValue[op] = wsdStat.nowValue[op];
+      }
+      return SQLITE_OK;
+    }
+    /*
+    ** Query status information for a single database connection
+    */
+    int sqlite3_db_status(
+    sqlite3 db,          /* The database connection whose status is desired */
+    int op,              /* Status verb */
+    ref int pCurrent,    /* Write current value here */
+    ref int pHighwater,  /* Write high-water mark here */
+    int resetFlag        /* Reset high-water mark if true */
+    )
+    {
+      switch ( op )
+      {
+        case SQLITE_DBSTATUS_LOOKASIDE_USED:
+          {
+            pCurrent = db.lookaside.nOut;
+            pHighwater = db.lookaside.mxOut;
+            if ( resetFlag != 0 )
+            {
+              db.lookaside.mxOut = db.lookaside.nOut;
+            }
+            break;
+          }
+        default:
+          {
+            return SQLITE_ERROR;
+          }
+      }
+      return SQLITE_OK;
+    }
+  }
+}

data/platform/wp7/sqlite3/SqliteWrapper/table_c.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Diagnostics;
+
+using i64 = System.Int64;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 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.
+    **
+    *************************************************************************
+    ** This file contains the sqlite3_get_table() and //sqlite3_free_table()
+    ** interface routines.  These are just wrappers around the main
+    ** interface routine of sqlite3_exec().
+    **
+    ** These routines are in a separate files so that they will not be linked
+    ** if they are not used.
+    *************************************************************************
+    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
+    **  C#-SQLite is an independent reimplementation of the SQLite software library
+    **
+    **  SQLITE_SOURCE_ID: 2009-12-07 16:39:13 1ed88e9d01e9eda5cbc622e7614277f29bcc551c
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+    //#include <stdlib.h>
+    //#include <string.h>
+
+#if !SQLITE_OMIT_GET_TABLE
+
+/*
+** This structure is used to pass data from sqlite3_get_table() through
+** to the callback function is uses to build the result.
+*/
+class TabResult {
+public string[] azResult;
+public string zErrMsg;
+public int nResult;
+public int nAlloc;
+public int nRow;
+public int nColumn;
+public int nData;
+public int rc;
+};
+
+/*
+** This routine is called once for each row in the result table.  Its job
+** is to fill in the TabResult structure appropriately, allocating new
+** memory as necessary.
+*/
+static public int sqlite3_get_table_cb( object pArg, i64 nCol, object Oargv, object Ocolv )
+{
+string[] argv = (string[])Oargv;
+string[]colv = (string[])Ocolv;
+TabResult p = (TabResult)pArg;
+int need;
+int i;
+string z;
+
+/* Make sure there is enough space in p.azResult to hold everything
+** we need to remember from this invocation of the callback.
+*/
+if( p.nRow==0 && argv!=null ){
+need = (int)nCol*2;
+}else{
+need = (int)nCol;
+}
+if( p.nData + need >= p.nAlloc ){
+string[] azNew;
+p.nAlloc = p.nAlloc*2 + need + 1;
+azNew = new string[p.nAlloc];//sqlite3_realloc( p.azResult, sizeof(char*)*p.nAlloc );
+if( azNew==null ) goto malloc_failed;
+p.azResult = azNew;
+}
+
+/* If this is the first row, then generate an extra row containing
+** the names of all columns.
+*/
+if( p.nRow==0 ){
+p.nColumn = (int)nCol;
+for(i=0; i<nCol; i++){
+z = sqlite3_mprintf("%s", colv[i]);
+if( z==null ) goto malloc_failed;
+p.azResult[p.nData++ -1] = z;
+}
+}else if( p.nColumn!=nCol ){
+//sqlite3_free(ref p.zErrMsg);
+p.zErrMsg = sqlite3_mprintf(
+"sqlite3_get_table() called with two or more incompatible queries"
+);
+p.rc = SQLITE_ERROR;
+return 1;
+}
+
+/* Copy over the row data
+*/
+if( argv!=null ){
+for(i=0; i<nCol; i++){
+if( argv[i]==null ){
+z = null;
+}else{
+int n = sqlite3Strlen30(argv[i])+1;
+//z = sqlite3_malloc( n );
+//if( z==0 ) goto malloc_failed;
+z= argv[i];//memcpy(z, argv[i], n);
+}
+p.azResult[p.nData++ -1] = z;
+}
+p.nRow++;
+}
+return 0;
+
+malloc_failed:
+p.rc = SQLITE_NOMEM;
+return 1;
+}
+
+/*
+** Query the database.  But instead of invoking a callback for each row,
+** malloc() for space to hold the result and return the entire results
+** at the conclusion of the call.
+**
+** The result that is written to ***pazResult is held in memory obtained
+** from malloc().  But the caller cannot free this memory directly.
+** Instead, the entire table should be passed to //sqlite3_free_table() when
+** the calling procedure is finished using it.
+*/
+static public int sqlite3_get_table(
+sqlite3 db,               /* The database on which the SQL executes */
+string zSql,              /* The SQL to be executed */
+ref string[] pazResult,   /* Write the result table here */
+ref int pnRow,            /* Write the number of rows in the result here */
+ref int pnColumn,         /* Write the number of columns of result here */
+ref string pzErrMsg       /* Write error messages here */
+){
+int rc;
+TabResult res = new TabResult();
+
+pazResult = null;
+pnColumn = 0;
+pnRow = 0;
+pzErrMsg = "";
+res.zErrMsg = "";
+res.nResult = 0;
+res.nRow = 0;
+res.nColumn = 0;
+res.nData = 1;
+res.nAlloc = 20;
+res.rc = SQLITE_OK;
+res.azResult = new string[res.nAlloc];// sqlite3_malloc( sizeof( char* ) * res.nAlloc );
+if( res.azResult==null ){
+db.errCode = SQLITE_NOMEM;
+return SQLITE_NOMEM;
+}
+res.azResult[0] = null;
+rc = sqlite3_exec(db, zSql, (dxCallback) sqlite3_get_table_cb, res, ref pzErrMsg);
+//Debug.Assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
+//res.azResult = SQLITE_INT_TO_PTR( res.nData );
+if( (rc&0xff)==SQLITE_ABORT ){
+//sqlite3_free_table(ref res.azResult[1] );
+if( res.zErrMsg !=""){
+if( pzErrMsg !=null ){
+//sqlite3_free(ref pzErrMsg);
+pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
+}
+//sqlite3_free(ref res.zErrMsg);
+}
+db.errCode = res.rc;  /* Assume 32-bit assignment is atomic */
+return res.rc;
+}
+//sqlite3_free(ref res.zErrMsg);
+if( rc!=SQLITE_OK ){
+//sqlite3_free_table(ref res.azResult[1]);
+return rc;
+}
+if( res.nAlloc>res.nData ){
+string[] azNew;
+Array.Resize(ref res.azResult, res.nData-1);//sqlite3_realloc( res.azResult, sizeof(char*)*(res.nData+1) );
+//if( azNew==null ){
+//  //sqlite3_free_table(ref res.azResult[1]);
+//  db.errCode = SQLITE_NOMEM;
+//  return SQLITE_NOMEM;
+//}
+res.nAlloc = res.nData+1;
+//res.azResult = azNew;
+}
+pazResult = res.azResult;
+pnColumn = res.nColumn;
+pnRow = res.nRow;
+return rc;
+}
+
+/*
+** This routine frees the space the sqlite3_get_table() malloced.
+*/
+static void //sqlite3_free_table(
+ref string azResult            /* Result returned from from sqlite3_get_table() */
+){
+if( azResult !=null){
+int i, n;
+//azResult--;
+//Debug.Assert( azResult!=0 );
+//n = SQLITE_PTR_TO_INT(azResult[0]);
+//for(i=1; i<n; i++){ if( azResult[i] ) //sqlite3_free(azResult[i]); }
+//sqlite3_free(ref azResult);
+}
+}
+
+#endif //* SQLITE_OMIT_GET_TABLE */
+  }
+}