System.Data.SQLite
Check-in [9067143122]
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Update to SQlite 3.7.6.3 [ed1da510a2].
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: 9067143122d3b1e60b093da050d48dd156b72352
User & Date: shaneh 2011-06-02 15:17:57
Original Comment: Update to SQlite 3.7.6.3 [ed1da510a2].
Context
2011-06-02
15:31
Update the version number to 1.0.73.0. check-in: e7dae3da63 user: shaneh tags: trunk
15:17
Update to SQlite 3.7.6.3 [ed1da510a2]. check-in: 9067143122 user: shaneh tags: trunk
2011-05-24
01:39
Minor optimization to GetBytes() to avoid calling sqlite3_column_blob() on null destination buffers. Fix for [8c1650482e]. check-in: a97d149d1e user: shaneh tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to SQLite.Interop/src/core/sqlite3.c.

     1      1   /******************************************************************************
     2      2   ** This file is an amalgamation of many separate C source files from SQLite
     3         -** version 3.7.6.1.  By combining all the individual C code files into this 
            3  +** version 3.7.6.3.  By combining all the individual C code files into this 
     4      4   ** single large file, the entire code can be compiled as a single translation
     5      5   ** unit.  This allows many compilers to do optimizations that would not be
     6      6   ** possible if the files were compiled separately.  Performance improvements
     7      7   ** of 5% or more are commonly seen when SQLite is compiled as a single
     8      8   ** translation unit.
     9      9   **
    10     10   ** This file is all you need to compile SQLite.  To use SQLite in other
................................................................................
   646    646   ** string contains the date and time of the check-in (UTC) and an SHA1
   647    647   ** hash of the entire source tree.
   648    648   **
   649    649   ** See also: [sqlite3_libversion()],
   650    650   ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
   651    651   ** [sqlite_version()] and [sqlite_source_id()].
   652    652   */
   653         -#define SQLITE_VERSION        "3.7.6.1"
          653  +#define SQLITE_VERSION        "3.7.6.3"
   654    654   #define SQLITE_VERSION_NUMBER 3007006
   655         -#define SQLITE_SOURCE_ID      "2011-04-27 18:08:42 1bd1484cd7e09709d87aa84b82e87597d00a4162"
          655  +#define SQLITE_SOURCE_ID      "2011-05-19 13:26:54 ed1da510a239ea767a01dc332b667119fa3c908e"
   656    656   
   657    657   /*
   658    658   ** CAPI3REF: Run-Time Library Version Numbers
   659    659   ** KEYWORDS: sqlite3_version, sqlite3_sourceid
   660    660   **
   661    661   ** These interfaces provide the same information as the [SQLITE_VERSION],
   662    662   ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
   991    991   #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
   992    992   #define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
   993    993   #define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
   994    994   #define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
   995    995   #define SQLITE_IOERR_SHMOPEN           (SQLITE_IOERR | (18<<8))
   996    996   #define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))
   997    997   #define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))
   998         -#define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))
   999         -#define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))
  1000    998   #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
  1001    999   #define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
  1002   1000   #define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
  1003   1001   
  1004   1002   /*
  1005   1003   ** CAPI3REF: Flags For File Open Operations
  1006   1004   **
................................................................................
 17948  17946     int nFull;
 17949  17947     void *p;
 17950  17948     assert( sqlite3_mutex_held(mem0.mutex) );
 17951  17949     nFull = sqlite3GlobalConfig.m.xRoundup(n);
 17952  17950     sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);
 17953  17951     if( mem0.alarmCallback!=0 ){
 17954  17952       int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
 17955         -    if( nUsed >= mem0.alarmThreshold - nFull ){
        17953  +    if( nUsed+nFull >= mem0.alarmThreshold ){
 17956  17954         mem0.nearlyFull = 1;
 17957  17955         sqlite3MallocAlarm(nFull);
 17958  17956       }else{
 17959  17957         mem0.nearlyFull = 0;
 17960  17958       }
 17961  17959     }
 17962  17960     p = sqlite3GlobalConfig.m.xMalloc(nFull);
................................................................................
 18189  18187     sqlite3_free(p);
 18190  18188   }
 18191  18189   
 18192  18190   /*
 18193  18191   ** Change the size of an existing memory allocation
 18194  18192   */
 18195  18193   SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, int nBytes){
 18196         -  int nOld, nNew, nDiff;
        18194  +  int nOld, nNew;
 18197  18195     void *pNew;
 18198  18196     if( pOld==0 ){
 18199  18197       return sqlite3Malloc(nBytes); /* IMP: R-28354-25769 */
 18200  18198     }
 18201  18199     if( nBytes<=0 ){
 18202  18200       sqlite3_free(pOld); /* IMP: R-31593-10574 */
 18203  18201       return 0;
................................................................................
 18212  18210     ** xRoundup. */
 18213  18211     nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
 18214  18212     if( nOld==nNew ){
 18215  18213       pNew = pOld;
 18216  18214     }else if( sqlite3GlobalConfig.bMemstat ){
 18217  18215       sqlite3_mutex_enter(mem0.mutex);
 18218  18216       sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
 18219         -    nDiff = nNew - nOld;
 18220         -    if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >= 
 18221         -          mem0.alarmThreshold-nDiff ){
        18217  +    if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)+nNew-nOld >= 
        18218  +          mem0.alarmThreshold ){
 18222  18219         sqlite3MallocAlarm(nNew-nOld);
 18223  18220       }
 18224  18221       assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
 18225  18222       assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );
 18226  18223       pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
 18227  18224       if( pNew==0 && mem0.alarmCallback ){
 18228  18225         sqlite3MallocAlarm(nBytes);
 18229  18226         pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
 18230  18227       }
 18231  18228       if( pNew ){
 18232  18229         nNew = sqlite3MallocSize(pNew);
 18233         -      sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nDiff);
        18230  +      sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
 18234  18231       }
 18235  18232       sqlite3_mutex_leave(mem0.mutex);
 18236  18233     }else{
 18237  18234       pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
 18238  18235     }
 18239  18236     assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-04675-44850 */
 18240  18237     return pNew;
................................................................................
 24400  24397   */
 24401  24398   #if SQLITE_THREADSAFE
 24402  24399   #define threadid pthread_self()
 24403  24400   #else
 24404  24401   #define threadid 0
 24405  24402   #endif
 24406  24403   
 24407         -/*
 24408         -** Different Unix systems declare open() in different ways.  Same use
 24409         -** open(const char*,int,mode_t).  Others use open(const char*,int,...).
 24410         -** The difference is important when using a pointer to the function.
 24411         -**
 24412         -** The safest way to deal with the problem is to always use this wrapper
 24413         -** which always has the same well-defined interface.
 24414         -*/
 24415         -static int posixOpen(const char *zFile, int flags, int mode){
 24416         -  return open(zFile, flags, mode);
 24417         -}
 24418         -
 24419  24404   /*
 24420  24405   ** Many system calls are accessed through pointer-to-functions so that
 24421  24406   ** they may be overridden at runtime to facilitate fault injection during
 24422  24407   ** testing and sandboxing.  The following array holds the names and pointers
 24423  24408   ** to all overrideable system calls.
 24424  24409   */
 24425  24410   static struct unix_syscall {
 24426  24411     const char *zName;            /* Name of the sytem call */
 24427  24412     sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
 24428  24413     sqlite3_syscall_ptr pDefault; /* Default value */
 24429  24414   } aSyscall[] = {
 24430         -  { "open",         (sqlite3_syscall_ptr)posixOpen,  0  },
 24431         -#define osOpen      ((int(*)(const char*,int,int))aSyscall[0].pCurrent)
        24415  +  { "open",         (sqlite3_syscall_ptr)open,       0  },
        24416  +#define osOpen      ((int(*)(const char*,int,...))aSyscall[0].pCurrent)
 24432  24417   
 24433  24418     { "close",        (sqlite3_syscall_ptr)close,      0  },
 24434  24419   #define osClose     ((int(*)(int))aSyscall[1].pCurrent)
 24435  24420   
 24436  24421     { "access",       (sqlite3_syscall_ptr)access,     0  },
 24437  24422   #define osAccess    ((int(*)(const char*,int))aSyscall[2].pCurrent)
 24438  24423   
................................................................................
 24461  24446   
 24462  24447     { "fcntl",        (sqlite3_syscall_ptr)fcntl,      0  },
 24463  24448   #define osFcntl     ((int(*)(int,int,...))aSyscall[7].pCurrent)
 24464  24449   
 24465  24450     { "read",         (sqlite3_syscall_ptr)read,       0  },
 24466  24451   #define osRead      ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)
 24467  24452   
 24468         -#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
        24453  +#if defined(USE_PREAD) || defined(SQLITE_ENABLE_LOCKING_STYLE)
 24469  24454     { "pread",        (sqlite3_syscall_ptr)pread,      0  },
 24470  24455   #else
 24471  24456     { "pread",        (sqlite3_syscall_ptr)0,          0  },
 24472  24457   #endif
 24473  24458   #define osPread     ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)
 24474  24459   
 24475  24460   #if defined(USE_PREAD64)
................................................................................
 24478  24463     { "pread64",      (sqlite3_syscall_ptr)0,          0  },
 24479  24464   #endif
 24480  24465   #define osPread64   ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)
 24481  24466   
 24482  24467     { "write",        (sqlite3_syscall_ptr)write,      0  },
 24483  24468   #define osWrite     ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)
 24484  24469   
 24485         -#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
        24470  +#if defined(USE_PREAD) || defined(SQLITE_ENABLE_LOCKING_STYLE)
 24486  24471     { "pwrite",       (sqlite3_syscall_ptr)pwrite,     0  },
 24487  24472   #else
 24488  24473     { "pwrite",       (sqlite3_syscall_ptr)0,          0  },
 24489  24474   #endif
 24490  24475   #define osPwrite    ((ssize_t(*)(int,const void*,size_t,off_t))\
 24491  24476                       aSyscall[12].pCurrent)
 24492  24477   
................................................................................
 25064  25049     unsigned char bProcessLock;     /* An exclusive process lock is held */
 25065  25050     int nRef;                       /* Number of pointers to this structure */
 25066  25051     unixShmNode *pShmNode;          /* Shared memory associated with this inode */
 25067  25052     int nLock;                      /* Number of outstanding file locks */
 25068  25053     UnixUnusedFd *pUnused;          /* Unused file descriptors to close */
 25069  25054     unixInodeInfo *pNext;           /* List of all unixInodeInfo objects */
 25070  25055     unixInodeInfo *pPrev;           /*    .... doubly linked */
 25071         -#if SQLITE_ENABLE_LOCKING_STYLE
        25056  +#if defined(SQLITE_ENABLE_LOCKING_STYLE)
 25072  25057     unsigned long long sharedByte;  /* for AFP simulated shared lock */
 25073  25058   #endif
 25074  25059   #if OS_VXWORKS
 25075  25060     sem_t *pSem;                    /* Named POSIX semaphore */
 25076  25061     char aSemName[MAX_PATHNAME+2];  /* Name of that semaphore */
 25077  25062   #endif
 25078  25063   };
................................................................................
 27221  27206       offset += wrote;
 27222  27207       pBuf = &((char*)pBuf)[wrote];
 27223  27208     }
 27224  27209     SimulateIOError(( wrote=(-1), amt=1 ));
 27225  27210     SimulateDiskfullError(( wrote=0, amt=1 ));
 27226  27211   
 27227  27212     if( amt>0 ){
 27228         -    if( wrote<0 && pFile->lastErrno!=ENOSPC ){
        27213  +    if( wrote<0 ){
 27229  27214         /* lastErrno set by seekAndWrite */
 27230  27215         return SQLITE_IOERR_WRITE;
 27231  27216       }else{
 27232  27217         pFile->lastErrno = 0; /* not a system error */
 27233  27218         return SQLITE_FULL;
 27234  27219       }
 27235  27220     }
................................................................................
 28046  28031       while(pShmNode->nRegion<=iRegion){
 28047  28032         void *pMem;
 28048  28033         if( pShmNode->h>=0 ){
 28049  28034           pMem = mmap(0, szRegion, PROT_READ|PROT_WRITE, 
 28050  28035               MAP_SHARED, pShmNode->h, pShmNode->nRegion*szRegion
 28051  28036           );
 28052  28037           if( pMem==MAP_FAILED ){
 28053         -          rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
        28038  +          rc = SQLITE_IOERR;
 28054  28039             goto shmpage_out;
 28055  28040           }
 28056  28041         }else{
 28057  28042           pMem = sqlite3_malloc(szRegion);
 28058  28043           if( pMem==0 ){
 28059  28044             rc = SQLITE_NOMEM;
 28060  28045             goto shmpage_out;
................................................................................
 31167  31152     HANDLE hMutex;          /* Mutex used to control access to shared lock */  
 31168  31153     HANDLE hShared;         /* Shared memory segment used for locking */
 31169  31154     winceLock local;        /* Locks obtained by this instance of winFile */
 31170  31155     winceLock *shared;      /* Global shared lock memory for the file  */
 31171  31156   #endif
 31172  31157   };
 31173  31158   
 31174         -
 31175  31159   /*
 31176  31160   ** Forward prototypes.
 31177  31161   */
 31178  31162   static int getSectorSize(
 31179  31163       sqlite3_vfs *pVfs,
 31180  31164       const char *zRelative     /* UTF-8 file name */
 31181  31165   );
................................................................................
 31335  31319     return zFilenameUtf8;
 31336  31320   }
 31337  31321   
 31338  31322   /*
 31339  31323   ** Convert UTF-8 to multibyte character string.  Space to hold the 
 31340  31324   ** returned string is obtained from malloc().
 31341  31325   */
 31342         -SQLITE_API char *sqlite3_win32_utf8_to_mbcs(const char *zFilename){
        31326  +static char *utf8ToMbcs(const char *zFilename){
 31343  31327     char *zFilenameMbcs;
 31344  31328     WCHAR *zTmpWide;
 31345  31329   
 31346  31330     zTmpWide = utf8ToUnicode(zFilename);
 31347  31331     if( zTmpWide==0 ){
 31348  31332       return 0;
 31349  31333     }
 31350  31334     zFilenameMbcs = unicodeToMbcs(zTmpWide);
 31351  31335     free(zTmpWide);
 31352  31336     return zFilenameMbcs;
 31353  31337   }
 31354  31338   
 31355         -
 31356         -/*
 31357         -** The return value of getLastErrorMsg
 31358         -** is zero if the error message fits in the buffer, or non-zero
 31359         -** otherwise (if the message was truncated).
 31360         -*/
 31361         -static int getLastErrorMsg(int nBuf, char *zBuf){
 31362         -  /* FormatMessage returns 0 on failure.  Otherwise it
 31363         -  ** returns the number of TCHARs written to the output
 31364         -  ** buffer, excluding the terminating null char.
 31365         -  */
 31366         -  DWORD error = GetLastError();
 31367         -  DWORD dwLen = 0;
 31368         -  char *zOut = 0;
 31369         -
 31370         -  if( isNT() ){
 31371         -    WCHAR *zTempWide = NULL;
 31372         -    dwLen = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
 31373         -                           NULL,
 31374         -                           error,
 31375         -                           0,
 31376         -                           (LPWSTR) &zTempWide,
 31377         -                           0,
 31378         -                           0);
 31379         -    if( dwLen > 0 ){
 31380         -      /* allocate a buffer and convert to UTF8 */
 31381         -      zOut = unicodeToUtf8(zTempWide);
 31382         -      /* free the system buffer allocated by FormatMessage */
 31383         -      LocalFree(zTempWide);
 31384         -    }
 31385         -/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed. 
 31386         -** Since the ASCII version of these Windows API do not exist for WINCE,
 31387         -** it's important to not reference them for WINCE builds.
 31388         -*/
 31389         -#if SQLITE_OS_WINCE==0
 31390         -  }else{
 31391         -    char *zTemp = NULL;
 31392         -    dwLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
 31393         -                           NULL,
 31394         -                           error,
 31395         -                           0,
 31396         -                           (LPSTR) &zTemp,
 31397         -                           0,
 31398         -                           0);
 31399         -    if( dwLen > 0 ){
 31400         -      /* allocate a buffer and convert to UTF8 */
 31401         -      zOut = sqlite3_win32_mbcs_to_utf8(zTemp);
 31402         -      /* free the system buffer allocated by FormatMessage */
 31403         -      LocalFree(zTemp);
 31404         -    }
 31405         -#endif
 31406         -  }
 31407         -  if( 0 == dwLen ){
 31408         -    sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
 31409         -  }else{
 31410         -    /* copy a maximum of nBuf chars to output buffer */
 31411         -    sqlite3_snprintf(nBuf, zBuf, "%s", zOut);
 31412         -    /* free the UTF8 buffer */
 31413         -    free(zOut);
 31414         -  }
 31415         -  return 0;
 31416         -}
 31417         -
 31418         -/*
 31419         -**
 31420         -** This function - winLogErrorAtLine() - is only ever called via the macro
 31421         -** winLogError().
 31422         -**
 31423         -** This routine is invoked after an error occurs in an OS function.
 31424         -** It logs a message using sqlite3_log() containing the current value of
 31425         -** error code and, if possible, the human-readable equivalent from 
 31426         -** FormatMessage.
 31427         -**
 31428         -** The first argument passed to the macro should be the error code that
 31429         -** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN). 
 31430         -** The two subsequent arguments should be the name of the OS function that
 31431         -** failed and the the associated file-system path, if any.
 31432         -*/
 31433         -#define winLogError(a,b,c)     winLogErrorAtLine(a,b,c,__LINE__)
 31434         -static int winLogErrorAtLine(
 31435         -  int errcode,                    /* SQLite error code */
 31436         -  const char *zFunc,              /* Name of OS function that failed */
 31437         -  const char *zPath,              /* File path associated with error */
 31438         -  int iLine                       /* Source line number where error occurred */
 31439         -){
 31440         -  char zMsg[500];                 /* Human readable error text */
 31441         -  int i;                          /* Loop counter */
 31442         -  DWORD iErrno = GetLastError();  /* Error code */
 31443         -
 31444         -  zMsg[0] = 0;
 31445         -  getLastErrorMsg(sizeof(zMsg), zMsg);
 31446         -  assert( errcode!=SQLITE_OK );
 31447         -  if( zPath==0 ) zPath = "";
 31448         -  for(i=0; zMsg[i] && zMsg[i]!='\r' && zMsg[i]!='\n'; i++){}
 31449         -  zMsg[i] = 0;
 31450         -  sqlite3_log(errcode,
 31451         -      "os_win.c:%d: (%d) %s(%s) - %s",
 31452         -      iLine, iErrno, zFunc, zPath, zMsg
 31453         -  );
 31454         -
 31455         -  return errcode;
 31456         -}
 31457         -
 31458  31339   #if SQLITE_OS_WINCE
 31459  31340   /*************************************************************************
 31460  31341   ** This section contains code for WinCE only.
 31461  31342   */
 31462  31343   /*
 31463  31344   ** WindowsCE does not have a localtime() function.  So create a
 31464  31345   ** substitute.
................................................................................
 31527  31408       if (*zTok == '\\') *zTok = '_';
 31528  31409     }
 31529  31410   
 31530  31411     /* Create/open the named mutex */
 31531  31412     pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
 31532  31413     if (!pFile->hMutex){
 31533  31414       pFile->lastErrno = GetLastError();
 31534         -    winLogError(SQLITE_ERROR, "winceCreateLock1", zFilename);
 31535  31415       free(zName);
 31536  31416       return FALSE;
 31537  31417     }
 31538  31418   
 31539  31419     /* Acquire the mutex before continuing */
 31540  31420     winceMutexAcquire(pFile->hMutex);
 31541  31421     
................................................................................
 31559  31439     /* If we succeeded in making the shared memory handle, map it. */
 31560  31440     if (pFile->hShared){
 31561  31441       pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared, 
 31562  31442                FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
 31563  31443       /* If mapping failed, close the shared memory handle and erase it */
 31564  31444       if (!pFile->shared){
 31565  31445         pFile->lastErrno = GetLastError();
 31566         -      winLogError(SQLITE_ERROR, "winceCreateLock2", zFilename);
 31567  31446         CloseHandle(pFile->hShared);
 31568  31447         pFile->hShared = NULL;
 31569  31448       }
 31570  31449     }
 31571  31450   
 31572  31451     /* If shared memory could not be created, then close the mutex and fail */
 31573  31452     if (pFile->hShared == NULL){
................................................................................
 31805  31684     ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine 
 31806  31685     ** whether an error has actually occured, it is also necessary to call 
 31807  31686     ** GetLastError().
 31808  31687     */
 31809  31688     dwRet = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
 31810  31689     if( (dwRet==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR) ){
 31811  31690       pFile->lastErrno = GetLastError();
 31812         -    winLogError(SQLITE_IOERR_SEEK, "seekWinFile", pFile->zPath);
 31813  31691       return 1;
 31814  31692     }
 31815  31693   
 31816  31694     return 0;
 31817  31695   }
 31818  31696   
 31819  31697   /*
................................................................................
 31851  31729          Sleep(100);  /* Wait a little before trying again */
 31852  31730       }
 31853  31731       free(pFile->zDeleteOnClose);
 31854  31732     }
 31855  31733   #endif
 31856  31734     OSTRACE(("CLOSE %d %s\n", pFile->h, rc ? "ok" : "failed"));
 31857  31735     OpenCounter(-1);
 31858         -  return rc ? SQLITE_OK
 31859         -            : winLogError(SQLITE_IOERR_CLOSE, "winClose", pFile->zPath);
        31736  +  return rc ? SQLITE_OK : SQLITE_IOERR;
 31860  31737   }
 31861  31738   
 31862  31739   /*
 31863  31740   ** Read data from a file into a buffer.  Return SQLITE_OK if all
 31864  31741   ** bytes were read successfully and SQLITE_IOERR if anything goes
 31865  31742   ** wrong.
 31866  31743   */
................................................................................
 31878  31755     OSTRACE(("READ %d lock=%d\n", pFile->h, pFile->locktype));
 31879  31756   
 31880  31757     if( seekWinFile(pFile, offset) ){
 31881  31758       return SQLITE_FULL;
 31882  31759     }
 31883  31760     if( !ReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
 31884  31761       pFile->lastErrno = GetLastError();
 31885         -    return winLogError(SQLITE_IOERR_READ, "winRead", pFile->zPath);
        31762  +    return SQLITE_IOERR_READ;
 31886  31763     }
 31887  31764     if( nRead<(DWORD)amt ){
 31888  31765       /* Unread parts of the buffer must be zero-filled */
 31889  31766       memset(&((char*)pBuf)[nRead], 0, amt-nRead);
 31890  31767       return SQLITE_IOERR_SHORT_READ;
 31891  31768     }
 31892  31769   
................................................................................
 31929  31806       }
 31930  31807     }
 31931  31808   
 31932  31809     if( rc ){
 31933  31810       if( pFile->lastErrno==ERROR_HANDLE_DISK_FULL ){
 31934  31811         return SQLITE_FULL;
 31935  31812       }
 31936         -    return winLogError(SQLITE_IOERR_WRITE, "winWrite", pFile->zPath);
        31813  +    return SQLITE_IOERR_WRITE;
 31937  31814     }
 31938  31815     return SQLITE_OK;
 31939  31816   }
 31940  31817   
 31941  31818   /*
 31942  31819   ** Truncate an open file to a specified size
 31943  31820   */
................................................................................
 31957  31834     */
 31958  31835     if( pFile->szChunk ){
 31959  31836       nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
 31960  31837     }
 31961  31838   
 31962  31839     /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
 31963  31840     if( seekWinFile(pFile, nByte) ){
 31964         -    rc = winLogError(SQLITE_IOERR_TRUNCATE, "winTruncate1", pFile->zPath);
        31841  +    rc = SQLITE_IOERR_TRUNCATE;
 31965  31842     }else if( 0==SetEndOfFile(pFile->h) ){
 31966  31843       pFile->lastErrno = GetLastError();
 31967         -    rc = winLogError(SQLITE_IOERR_TRUNCATE, "winTruncate2", pFile->zPath);
        31844  +    rc = SQLITE_IOERR_TRUNCATE;
 31968  31845     }
 31969  31846   
 31970  31847     OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
 31971  31848     return rc;
 31972  31849   }
 31973  31850   
 31974  31851   #ifdef SQLITE_TEST
................................................................................
 31982  31859   
 31983  31860   /*
 31984  31861   ** Make sure all writes to a particular file are committed to disk.
 31985  31862   */
 31986  31863   static int winSync(sqlite3_file *id, int flags){
 31987  31864   #if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || defined(SQLITE_DEBUG)
 31988  31865     winFile *pFile = (winFile*)id;
 31989         -  BOOL rc;
 31990  31866   #else
 31991  31867     UNUSED_PARAMETER(id);
 31992  31868   #endif
 31993  31869   
 31994  31870     assert( pFile );
 31995  31871     /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
 31996  31872     assert((flags&0x0F)==SQLITE_SYNC_NORMAL
 31997  31873         || (flags&0x0F)==SQLITE_SYNC_FULL
 31998  31874     );
 31999  31875   
 32000  31876     OSTRACE(("SYNC %d lock=%d\n", pFile->h, pFile->locktype));
 32001  31877   
 32002         -  /* Unix cannot, but some systems may return SQLITE_FULL from here. This
 32003         -  ** line is to test that doing so does not cause any problems.
 32004         -  */
 32005         -  SimulateDiskfullError( return SQLITE_FULL );
 32006         -
 32007  31878   #ifndef SQLITE_TEST
 32008  31879     UNUSED_PARAMETER(flags);
 32009  31880   #else
 32010         -  if( (flags&0x0F)==SQLITE_SYNC_FULL ){
        31881  +  if( flags & SQLITE_SYNC_FULL ){
 32011  31882       sqlite3_fullsync_count++;
 32012  31883     }
 32013  31884     sqlite3_sync_count++;
 32014  31885   #endif
        31886  +
        31887  +  /* Unix cannot, but some systems may return SQLITE_FULL from here. This
        31888  +  ** line is to test that doing so does not cause any problems.
        31889  +  */
        31890  +  SimulateDiskfullError( return SQLITE_FULL );
        31891  +  SimulateIOError( return SQLITE_IOERR; );
 32015  31892   
 32016  31893     /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
 32017  31894     ** no-op
 32018  31895     */
 32019  31896   #ifdef SQLITE_NO_SYNC
 32020  31897     return SQLITE_OK;
 32021  31898   #else
 32022         -  rc = FlushFileBuffers(pFile->h);
 32023         -  SimulateIOError( rc=FALSE );
 32024         -  if( rc ){
        31899  +  if( FlushFileBuffers(pFile->h) ){
 32025  31900       return SQLITE_OK;
 32026  31901     }else{
 32027  31902       pFile->lastErrno = GetLastError();
 32028         -    return winLogError(SQLITE_IOERR_FSYNC, "winSync", pFile->zPath);
        31903  +    return SQLITE_IOERR;
 32029  31904     }
 32030  31905   #endif
 32031  31906   }
 32032  31907   
 32033  31908   /*
 32034  31909   ** Determine the current size of a file in bytes
 32035  31910   */
................................................................................
 32042  31917     assert( id!=0 );
 32043  31918     SimulateIOError(return SQLITE_IOERR_FSTAT);
 32044  31919     lowerBits = GetFileSize(pFile->h, &upperBits);
 32045  31920     if(   (lowerBits == INVALID_FILE_SIZE)
 32046  31921        && ((error = GetLastError()) != NO_ERROR) )
 32047  31922     {
 32048  31923       pFile->lastErrno = error;
 32049         -    return winLogError(SQLITE_IOERR_FSTAT, "winFileSize", pFile->zPath);
        31924  +    return SQLITE_IOERR_FSTAT;
 32050  31925     }
 32051  31926     *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;
 32052  31927     return SQLITE_OK;
 32053  31928   }
 32054  31929   
 32055  31930   /*
 32056  31931   ** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
................................................................................
 32081  31956       sqlite3_randomness(sizeof(lk), &lk);
 32082  31957       pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
 32083  31958       res = LockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
 32084  31959   #endif
 32085  31960     }
 32086  31961     if( res == 0 ){
 32087  31962       pFile->lastErrno = GetLastError();
 32088         -    /* No need to log a failure to lock */
 32089  31963     }
 32090  31964     return res;
 32091  31965   }
 32092  31966   
 32093  31967   /*
 32094  31968   ** Undo a readlock
 32095  31969   */
................................................................................
 32102  31976   #if SQLITE_OS_WINCE==0
 32103  31977     }else{
 32104  31978       res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
 32105  31979   #endif
 32106  31980     }
 32107  31981     if( res == 0 ){
 32108  31982       pFile->lastErrno = GetLastError();
 32109         -    winLogError(SQLITE_IOERR_UNLOCK, "unlockReadLock", pFile->zPath);
 32110  31983     }
 32111  31984     return res;
 32112  31985   }
 32113  31986   
 32114  31987   /*
 32115  31988   ** Lock the file with the lock specified by parameter locktype - one
 32116  31989   ** of the following:
................................................................................
 32303  32176             pFile->locktype, pFile->sharedLockByte));
 32304  32177     type = pFile->locktype;
 32305  32178     if( type>=EXCLUSIVE_LOCK ){
 32306  32179       UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
 32307  32180       if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
 32308  32181         /* This should never happen.  We should always be able to
 32309  32182         ** reacquire the read lock */
 32310         -      rc = winLogError(SQLITE_IOERR_UNLOCK, "winUnlock", pFile->zPath);
        32183  +      rc = SQLITE_IOERR_UNLOCK;
 32311  32184       }
 32312  32185     }
 32313  32186     if( type>=RESERVED_LOCK ){
 32314  32187       UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
 32315  32188     }
 32316  32189     if( locktype==NO_LOCK && type>=SHARED_LOCK ){
 32317  32190       unlockReadLock(pFile);
................................................................................
 32660  32533   
 32661  32534       /* Check to see if another process is holding the dead-man switch.
 32662  32535       ** If not, truncate the file to zero length. 
 32663  32536       */
 32664  32537       if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
 32665  32538         rc = winTruncate((sqlite3_file *)&pShmNode->hFile, 0);
 32666  32539         if( rc!=SQLITE_OK ){
 32667         -        rc = winLogError(SQLITE_IOERR_SHMOPEN, "winOpenShm", pDbFd->zPath);
        32540  +        rc = SQLITE_IOERR_SHMOPEN;
 32668  32541         }
 32669  32542       }
 32670  32543       if( rc==SQLITE_OK ){
 32671  32544         winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
 32672  32545         rc = winShmSystemLock(pShmNode, _SHM_RDLCK, WIN_SHM_DMS, 1);
 32673  32546       }
 32674  32547       if( rc ) goto shm_open_err;
................................................................................
 32919  32792   
 32920  32793       /* The requested region is not mapped into this processes address space.
 32921  32794       ** Check to see if it has been allocated (i.e. if the wal-index file is
 32922  32795       ** large enough to contain the requested region).
 32923  32796       */
 32924  32797       rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz);
 32925  32798       if( rc!=SQLITE_OK ){
 32926         -      rc = winLogError(SQLITE_IOERR_SHMSIZE, "winShmMap1", pDbFd->zPath);
        32799  +      rc = SQLITE_IOERR_SHMSIZE;
 32927  32800         goto shmpage_out;
 32928  32801       }
 32929  32802   
 32930  32803       if( sz<nByte ){
 32931  32804         /* The requested memory region does not exist. If isWrite is set to
 32932  32805         ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
 32933  32806         **
 32934  32807         ** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
 32935  32808         ** the requested memory region.
 32936  32809         */
 32937  32810         if( !isWrite ) goto shmpage_out;
 32938  32811         rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
 32939  32812         if( rc!=SQLITE_OK ){
 32940         -        rc = winLogError(SQLITE_IOERR_SHMSIZE, "winShmMap2", pDbFd->zPath);
        32813  +        rc = SQLITE_IOERR_SHMSIZE;
 32941  32814           goto shmpage_out;
 32942  32815         }
 32943  32816       }
 32944  32817   
 32945  32818       /* Map the requested memory region into this processes address space. */
 32946  32819       apNew = (struct ShmRegion *)sqlite3_realloc(
 32947  32820           pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0])
................................................................................
 32970  32843           );
 32971  32844           OSTRACE(("SHM-MAP pid-%d map region=%d offset=%d size=%d %s\n",
 32972  32845                    (int)GetCurrentProcessId(), pShmNode->nRegion, iOffset, szRegion,
 32973  32846                    pMap ? "ok" : "failed"));
 32974  32847         }
 32975  32848         if( !pMap ){
 32976  32849           pShmNode->lastErrno = GetLastError();
 32977         -        rc = winLogError(SQLITE_IOERR_SHMMAP, "winShmMap3", pDbFd->zPath);
        32850  +        rc = SQLITE_IOERR;
 32978  32851           if( hMap ) CloseHandle(hMap);
 32979  32852           goto shmpage_out;
 32980  32853         }
 32981  32854   
 32982  32855         pShmNode->aRegion[pShmNode->nRegion].pMap = pMap;
 32983  32856         pShmNode->aRegion[pShmNode->nRegion].hMap = hMap;
 32984  32857         pShmNode->nRegion++;
................................................................................
 33052  32925     void *zConverted = 0;
 33053  32926     if( isNT() ){
 33054  32927       zConverted = utf8ToUnicode(zFilename);
 33055  32928   /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed. 
 33056  32929   */
 33057  32930   #if SQLITE_OS_WINCE==0
 33058  32931     }else{
 33059         -    zConverted = sqlite3_win32_utf8_to_mbcs(zFilename);
        32932  +    zConverted = utf8ToMbcs(zFilename);
 33060  32933   #endif
 33061  32934     }
 33062  32935     /* caller will handle out of memory */
 33063  32936     return zConverted;
 33064  32937   }
 33065  32938   
 33066  32939   /*
................................................................................
 33131  33004       zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
 33132  33005     }
 33133  33006     zBuf[j] = 0;
 33134  33007   
 33135  33008     OSTRACE(("TEMP FILENAME: %s\n", zBuf));
 33136  33009     return SQLITE_OK; 
 33137  33010   }
        33011  +
        33012  +/*
        33013  +** The return value of getLastErrorMsg
        33014  +** is zero if the error message fits in the buffer, or non-zero
        33015  +** otherwise (if the message was truncated).
        33016  +*/
        33017  +static int getLastErrorMsg(int nBuf, char *zBuf){
        33018  +  /* FormatMessage returns 0 on failure.  Otherwise it
        33019  +  ** returns the number of TCHARs written to the output
        33020  +  ** buffer, excluding the terminating null char.
        33021  +  */
        33022  +  DWORD error = GetLastError();
        33023  +  DWORD dwLen = 0;
        33024  +  char *zOut = 0;
        33025  +
        33026  +  if( isNT() ){
        33027  +    WCHAR *zTempWide = NULL;
        33028  +    dwLen = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        33029  +                           NULL,
        33030  +                           error,
        33031  +                           0,
        33032  +                           (LPWSTR) &zTempWide,
        33033  +                           0,
        33034  +                           0);
        33035  +    if( dwLen > 0 ){
        33036  +      /* allocate a buffer and convert to UTF8 */
        33037  +      zOut = unicodeToUtf8(zTempWide);
        33038  +      /* free the system buffer allocated by FormatMessage */
        33039  +      LocalFree(zTempWide);
        33040  +    }
        33041  +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed. 
        33042  +** Since the ASCII version of these Windows API do not exist for WINCE,
        33043  +** it's important to not reference them for WINCE builds.
        33044  +*/
        33045  +#if SQLITE_OS_WINCE==0
        33046  +  }else{
        33047  +    char *zTemp = NULL;
        33048  +    dwLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        33049  +                           NULL,
        33050  +                           error,
        33051  +                           0,
        33052  +                           (LPSTR) &zTemp,
        33053  +                           0,
        33054  +                           0);
        33055  +    if( dwLen > 0 ){
        33056  +      /* allocate a buffer and convert to UTF8 */
        33057  +      zOut = sqlite3_win32_mbcs_to_utf8(zTemp);
        33058  +      /* free the system buffer allocated by FormatMessage */
        33059  +      LocalFree(zTemp);
        33060  +    }
        33061  +#endif
        33062  +  }
        33063  +  if( 0 == dwLen ){
        33064  +    sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
        33065  +  }else{
        33066  +    /* copy a maximum of nBuf chars to output buffer */
        33067  +    sqlite3_snprintf(nBuf, zBuf, "%s", zOut);
        33068  +    /* free the UTF8 buffer */
        33069  +    free(zOut);
        33070  +  }
        33071  +  return 0;
        33072  +}
 33138  33073   
 33139  33074   /*
 33140  33075   ** Open a file.
 33141  33076   */
 33142  33077   static int winOpen(
 33143  33078     sqlite3_vfs *pVfs,        /* Not used */
 33144  33079     const char *zName,        /* Name of the file (UTF-8) */
................................................................................
 33303  33238   
 33304  33239     OSTRACE(("OPEN %d %s 0x%lx %s\n", 
 33305  33240              h, zName, dwDesiredAccess, 
 33306  33241              h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
 33307  33242   
 33308  33243     if( h==INVALID_HANDLE_VALUE ){
 33309  33244       pFile->lastErrno = GetLastError();
 33310         -    winLogError(SQLITE_CANTOPEN, "winOpen", zUtf8Name);
 33311  33245       free(zConverted);
 33312  33246       if( isReadWrite ){
 33313  33247         return winOpen(pVfs, zName, id, 
 33314  33248                ((flags|SQLITE_OPEN_READONLY)&~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)), pOutFlags);
 33315  33249       }else{
 33316  33250         return SQLITE_CANTOPEN_BKPT;
 33317  33251       }
................................................................................
 33407  33341     }
 33408  33342     free(zConverted);
 33409  33343     OSTRACE(("DELETE \"%s\" %s\n", zFilename,
 33410  33344          ( (rc==INVALID_FILE_ATTRIBUTES) && (error==ERROR_FILE_NOT_FOUND)) ?
 33411  33345            "ok" : "failed" ));
 33412  33346    
 33413  33347     return (   (rc == INVALID_FILE_ATTRIBUTES) 
 33414         -          && (error == ERROR_FILE_NOT_FOUND)) ? SQLITE_OK :
 33415         -                 winLogError(SQLITE_IOERR_DELETE, "winDelete", zFilename);
        33348  +          && (error == ERROR_FILE_NOT_FOUND)) ? SQLITE_OK : SQLITE_IOERR_DELETE;
 33416  33349   }
 33417  33350   
 33418  33351   /*
 33419  33352   ** Check the existance and status of a file.
 33420  33353   */
 33421  33354   static int winAccess(
 33422  33355     sqlite3_vfs *pVfs,         /* Not used on win32 */
................................................................................
 33448  33381             && sAttrData.nFileSizeLow==0 ){
 33449  33382           attr = INVALID_FILE_ATTRIBUTES;
 33450  33383         }else{
 33451  33384           attr = sAttrData.dwFileAttributes;
 33452  33385         }
 33453  33386       }else{
 33454  33387         if( GetLastError()!=ERROR_FILE_NOT_FOUND ){
 33455         -        winLogError(SQLITE_IOERR_ACCESS, "winAccess", zFilename);
 33456  33388           free(zConverted);
 33457  33389           return SQLITE_IOERR_ACCESS;
 33458  33390         }else{
 33459  33391           attr = INVALID_FILE_ATTRIBUTES;
 33460  33392         }
 33461  33393       }
 33462  33394   /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed. 
................................................................................
 42136  42068       ** function has already been called, it is mostly a no-op.  However, any
 42137  42069       ** backup in progress needs to be restarted.
 42138  42070       */
 42139  42071       sqlite3BackupRestart(pPager->pBackup);
 42140  42072     }else{
 42141  42073       if( pagerUseWal(pPager) ){
 42142  42074         PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
        42075  +      PgHdr *pPageOne = 0;
        42076  +      if( pList==0 ){
        42077  +        /* Must have at least one page for the WAL commit flag.
        42078  +        ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
        42079  +        rc = sqlite3PagerGet(pPager, 1, &pPageOne);
        42080  +        pList = pPageOne;
        42081  +        pList->pDirty = 0;
        42082  +      }
        42083  +      assert( pList!=0 || rc!=SQLITE_OK );
 42143  42084         if( pList ){
 42144  42085           rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1, 
 42145  42086               (pPager->fullSync ? pPager->syncFlags : 0)
 42146  42087           );
 42147  42088         }
        42089  +      sqlite3PagerUnref(pPageOne);
 42148  42090         if( rc==SQLITE_OK ){
 42149  42091           sqlite3PcacheCleanAll(pPager->pPCache);
 42150  42092         }
 42151  42093       }else{
 42152  42094         /* The following block updates the change-counter. Exactly how it
 42153  42095         ** does this depends on whether or not the atomic-update optimization
 42154  42096         ** was enabled at compile time, and if this transaction meets the 
................................................................................
 59983  59925     mem1.enc = pKeyInfo->enc;
 59984  59926     mem1.db = pKeyInfo->db;
 59985  59927     /* mem1.flags = 0;  // Will be initialized by sqlite3VdbeSerialGet() */
 59986  59928     VVA_ONLY( mem1.zMalloc = 0; ) /* Only needed by assert() statements */
 59987  59929   
 59988  59930     /* Compilers may complain that mem1.u.i is potentially uninitialized.
 59989  59931     ** We could initialize it, as shown here, to silence those complaints.
 59990         -  ** But in fact, mem1.u.i will never actually be used uninitialized, and doing 
        59932  +  ** But in fact, mem1.u.i will never actually be used initialized, and doing 
 59991  59933     ** the unnecessary initialization has a measurable negative performance
 59992  59934     ** impact, since this routine is a very high runner.  And so, we choose
 59993  59935     ** to ignore the compiler warnings and leave this variable uninitialized.
 59994  59936     */
 59995  59937     /*  mem1.u.i = 0;  // not needed, here to silence compiler warning */
 59996  59938     
 59997  59939     idx1 = getVarint32(aKey1, szHdr1);
................................................................................
 82402  82344   ){
 82403  82345     UNUSED_PARAMETER2(NotUsed, NotUsed2);
 82404  82346     /* IMP: R-24470-31136 This function is an SQL wrapper around the
 82405  82347     ** sqlite3_sourceid() C interface. */
 82406  82348     sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
 82407  82349   }
 82408  82350   
 82409         -/*
 82410         -** Implementation of the sqlite_log() function.  This is a wrapper around
 82411         -** sqlite3_log().  The return value is NULL.  The function exists purely for
 82412         -** its side-effects.
 82413         -*/
 82414         -static void errlogFunc(
 82415         -  sqlite3_context *context,
 82416         -  int argc,
 82417         -  sqlite3_value **argv
 82418         -){
 82419         -  UNUSED_PARAMETER(argc);
 82420         -  UNUSED_PARAMETER(context);
 82421         -  sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
 82422         -}
 82423         -
 82424  82351   /*
 82425  82352   ** Implementation of the sqlite_compileoption_used() function.
 82426  82353   ** The result is an integer that identifies if the compiler option
 82427  82354   ** was used to build SQLite.
 82428  82355   */
 82429  82356   #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 82430  82357   static void compileoptionusedFunc(
................................................................................
 83184  83111   /*  FUNCTION(ifnull,             2, 0, 0, ifnullFunc       ), */
 83185  83112       {2,SQLITE_UTF8,SQLITE_FUNC_COALESCE,0,0,ifnullFunc,0,0,"ifnull",0,0},
 83186  83113       FUNCTION(random,             0, 0, 0, randomFunc       ),
 83187  83114       FUNCTION(randomblob,         1, 0, 0, randomBlob       ),
 83188  83115       FUNCTION(nullif,             2, 0, 1, nullifFunc       ),
 83189  83116       FUNCTION(sqlite_version,     0, 0, 0, versionFunc      ),
 83190  83117       FUNCTION(sqlite_source_id,   0, 0, 0, sourceidFunc     ),
 83191         -    FUNCTION(sqlite_log,         2, 0, 0, errlogFunc       ),
 83192  83118   #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 83193  83119       FUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc  ),
 83194  83120       FUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc  ),
 83195  83121   #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
 83196  83122       FUNCTION(quote,              1, 0, 0, quoteFunc        ),
 83197  83123       FUNCTION(last_insert_rowid,  0, 0, 0, last_insert_rowid),
 83198  83124       FUNCTION(changes,            0, 0, 0, changes          ),
................................................................................
 86161  86087         return 0;    /* pDestIdx has no corresponding index in pSrc */
 86162  86088       }
 86163  86089     }
 86164  86090   #ifndef SQLITE_OMIT_CHECK
 86165  86091     if( pDest->pCheck && sqlite3ExprCompare(pSrc->pCheck, pDest->pCheck) ){
 86166  86092       return 0;   /* Tables have different CHECK constraints.  Ticket #2252 */
 86167  86093     }
 86168         -#endif
 86169         -#ifndef SQLITE_OMIT_FOREIGN_KEY
 86170         -  /* Disallow the transfer optimization if the destination table constains
 86171         -  ** any foreign key constraints.  This is more restrictive than necessary.
 86172         -  ** But the main beneficiary of the transfer optimization is the VACUUM 
 86173         -  ** command, and the VACUUM command disables foreign key constraints.  So
 86174         -  ** the extra complication to make this rule less restrictive is probably
 86175         -  ** not worth the effort.  Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
 86176         -  */
 86177         -  if( (pParse->db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
 86178         -    return 0;
 86179         -  }
 86180  86094   #endif
 86181  86095   
 86182  86096     /* If we get this far, it means either:
 86183  86097     **
 86184  86098     **    *   We can always do the transfer if the table contains an
 86185  86099     **        an integer primary key
 86186  86100     **
................................................................................
 94118  94032           ** there is such an index, and it has less columns than the table
 94119  94033           ** does, then we can assume that it consumes less space on disk and
 94120  94034           ** will therefore be cheaper to scan to determine the query result.
 94121  94035           ** In this case set iRoot to the root page number of the index b-tree
 94122  94036           ** and pKeyInfo to the KeyInfo structure required to navigate the
 94123  94037           ** index.
 94124  94038           **
 94125         -        ** (2011-04-15) Do not do a full scan of an unordered index.
 94126         -        **
 94127  94039           ** In practice the KeyInfo structure will not be used. It is only 
 94128  94040           ** passed to keep OP_OpenRead happy.
 94129  94041           */
 94130  94042           for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
 94131         -          if( pIdx->bUnordered==0 && (!pBest || pIdx->nColumn<pBest->nColumn) ){
        94043  +          if( !pBest || pIdx->nColumn<pBest->nColumn ){
 94132  94044               pBest = pIdx;
 94133  94045             }
 94134  94046           }
 94135  94047           if( pBest && pBest->nColumn<pTab->nCol ){
 94136  94048             iRoot = pBest->tnum;
 94137  94049             pKeyInfo = sqlite3IndexKeyinfo(pParse, pBest);
 94138  94050           }
................................................................................
118244 118156     sqlite3_tokenizer_module const *pModule = pTokenizer->pModule;
118245 118157     sqlite3_tokenizer_cursor *pCsr;
118246 118158     int (*xNext)(sqlite3_tokenizer_cursor *pCursor,
118247 118159         const char**,int*,int*,int*,int*);
118248 118160   
118249 118161     assert( pTokenizer && pModule );
118250 118162   
118251         -  /* If the user has inserted a NULL value, this function may be called with
118252         -  ** zText==0. In this case, add zero token entries to the hash table and 
118253         -  ** return early. */
118254         -  if( zText==0 ){
118255         -    *pnWord = 0;
118256         -    return SQLITE_OK;
118257         -  }
118258         -
118259 118163     rc = pModule->xOpen(pTokenizer, zText, -1, &pCsr);
118260 118164     if( rc!=SQLITE_OK ){
118261 118165       return rc;
118262 118166     }
118263 118167     pCsr->pTokenizer = pTokenizer;
118264 118168   
118265 118169     xNext = pModule->xNext;
................................................................................
118342 118246   ** Argument apVal is the same as the similarly named argument passed to
118343 118247   ** fts3InsertData(). Parameter iDocid is the docid of the new row.
118344 118248   */
118345 118249   static int fts3InsertTerms(Fts3Table *p, sqlite3_value **apVal, u32 *aSz){
118346 118250     int i;                          /* Iterator variable */
118347 118251     for(i=2; i<p->nColumn+2; i++){
118348 118252       const char *zText = (const char *)sqlite3_value_text(apVal[i]);
118349         -    int rc = fts3PendingTermsAdd(p, zText, i-2, &aSz[i-2]);
118350         -    if( rc!=SQLITE_OK ){
118351         -      return rc;
       118253  +    if( zText ){
       118254  +      int rc = fts3PendingTermsAdd(p, zText, i-2, &aSz[i-2]);
       118255  +      if( rc!=SQLITE_OK ){
       118256  +        return rc;
       118257  +      }
118352 118258       }
118353 118259       aSz[p->nColumn] += sqlite3_value_bytes(apVal[i]);
118354 118260     }
118355 118261     return SQLITE_OK;
118356 118262   }
118357 118263   
118358 118264   /*

Changes to SQLite.Interop/src/core/sqlite3.h.

   103    103   ** string contains the date and time of the check-in (UTC) and an SHA1
   104    104   ** hash of the entire source tree.
   105    105   **
   106    106   ** See also: [sqlite3_libversion()],
   107    107   ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
   108    108   ** [sqlite_version()] and [sqlite_source_id()].
   109    109   */
   110         -#define SQLITE_VERSION        "3.7.6.1"
          110  +#define SQLITE_VERSION        "3.7.6.3"
   111    111   #define SQLITE_VERSION_NUMBER 3007006
   112         -#define SQLITE_SOURCE_ID      "2011-04-27 18:08:42 1bd1484cd7e09709d87aa84b82e87597d00a4162"
          112  +#define SQLITE_SOURCE_ID      "2011-05-19 13:26:54 ed1da510a239ea767a01dc332b667119fa3c908e"
   113    113   
   114    114   /*
   115    115   ** CAPI3REF: Run-Time Library Version Numbers
   116    116   ** KEYWORDS: sqlite3_version, sqlite3_sourceid
   117    117   **
   118    118   ** These interfaces provide the same information as the [SQLITE_VERSION],
   119    119   ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
   448    448   #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
   449    449   #define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
   450    450   #define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
   451    451   #define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
   452    452   #define SQLITE_IOERR_SHMOPEN           (SQLITE_IOERR | (18<<8))
   453    453   #define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))
   454    454   #define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))
   455         -#define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))
   456         -#define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))
   457    455   #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
   458    456   #define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
   459    457   #define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
   460    458   
   461    459   /*
   462    460   ** CAPI3REF: Flags For File Open Operations
   463    461   **