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

Changes to Makefile.msc.

    27     27   # 5 == SQLITE_ENABLE_IOTRACE: Enables output from the IOTRACE() macros.
    28     28   #
    29     29   DEBUG = 0
    30     30   
    31     31   # Version numbers and release number for the SQLite being compiled.
    32     32   #
    33     33   VERSION = 3.7
    34         -VERSION_NUMBER = 3007007
    35         -RELEASE = 3.7.7
           34  +VERSION_NUMBER = 3007008
           35  +RELEASE = 3.7.8
    36     36   
    37     37   # C Compiler and options for use in building executables that
    38     38   # will run on the platform that is doing the build.
    39     39   #
    40     40   BCC = cl.exe
    41     41   
    42     42   # C Compile and options for use in building executables that

Changes to src/expr.c.

  1570   1570   #ifndef SQLITE_OMIT_SUBQUERY
  1571   1571   int sqlite3CodeSubselect(
  1572   1572     Parse *pParse,          /* Parsing context */
  1573   1573     Expr *pExpr,            /* The IN, SELECT, or EXISTS operator */
  1574   1574     int rMayHaveNull,       /* Register that records whether NULLs exist in RHS */
  1575   1575     int isRowid             /* If true, LHS of IN operator is a rowid */
  1576   1576   ){
  1577         -  int testAddr = 0;                       /* One-time test address */
         1577  +  int testAddr = -1;                      /* One-time test address */
  1578   1578     int rReg = 0;                           /* Register storing resulting */
  1579   1579     Vdbe *v = sqlite3GetVdbe(pParse);
  1580   1580     if( NEVER(v==0) ) return 0;
  1581         -  assert( sqlite3VdbeCurrentAddr(v)>0 );
  1582   1581     sqlite3ExprCachePush(pParse);
  1583   1582   
  1584   1583     /* This code must be run in its entirety every time it is encountered
  1585   1584     ** if any of the following is true:
  1586   1585     **
  1587   1586     **    *  The right-hand side is a correlated subquery
  1588   1587     **    *  The right-hand side is an expression list containing variables
................................................................................
  1590   1589     **
  1591   1590     ** If all of the above are false, then we can run this code just once
  1592   1591     ** save the results, and reuse the same result on subsequent invocations.
  1593   1592     */
  1594   1593     if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->pTriggerTab ){
  1595   1594       int mem = ++pParse->nMem;
  1596   1595       testAddr = sqlite3VdbeAddOp1(v, OP_Once, mem);
  1597         -    assert( testAddr>0 || pParse->db->mallocFailed );
  1598   1596     }
  1599   1597   
  1600   1598   #ifndef SQLITE_OMIT_EXPLAIN
  1601   1599     if( pParse->explain==2 ){
  1602   1600       char *zMsg = sqlite3MPrintf(
  1603         -        pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr?"":"CORRELATED ",
         1601  +        pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr>=0?"":"CORRELATED ",
  1604   1602           pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
  1605   1603       );
  1606   1604       sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
  1607   1605     }
  1608   1606   #endif
  1609   1607   
  1610   1608     switch( pExpr->op ){
................................................................................
  1688   1686             int iValToIns;
  1689   1687   
  1690   1688             /* If the expression is not constant then we will need to
  1691   1689             ** disable the test that was generated above that makes sure
  1692   1690             ** this code only executes once.  Because for a non-constant
  1693   1691             ** expression we need to rerun this code each time.
  1694   1692             */
  1695         -          if( testAddr && !sqlite3ExprIsConstant(pE2) ){
         1693  +          if( testAddr>=0 && !sqlite3ExprIsConstant(pE2) ){
  1696   1694               sqlite3VdbeChangeToNoop(v, testAddr);
  1697         -            testAddr = 0;
         1695  +            testAddr = -1;
  1698   1696             }
  1699   1697   
  1700   1698             /* Evaluate the expression and insert it into the temp table */
  1701   1699             if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){
  1702   1700               sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
  1703   1701             }else{
  1704   1702               r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
................................................................................
  1759   1757         }
  1760   1758         rReg = dest.iParm;
  1761   1759         ExprSetIrreducible(pExpr);
  1762   1760         break;
  1763   1761       }
  1764   1762     }
  1765   1763   
  1766         -  if( testAddr ){
         1764  +  if( testAddr>=0 ){
  1767   1765       sqlite3VdbeJumpHere(v, testAddr);
  1768   1766     }
  1769   1767     sqlite3ExprCachePop(pParse, 1);
  1770   1768   
  1771   1769     return rReg;
  1772   1770   }
  1773   1771   #endif /* SQLITE_OMIT_SUBQUERY */

Changes to src/global.c.

   139    139   */
   140    140   SQLITE_WSD struct Sqlite3Config sqlite3Config = {
   141    141      SQLITE_DEFAULT_MEMSTATUS,  /* bMemstat */
   142    142      1,                         /* bCoreMutex */
   143    143      SQLITE_THREADSAFE==1,      /* bFullMutex */
   144    144      SQLITE_USE_URI,            /* bOpenUri */
   145    145      0x7ffffffe,                /* mxStrlen */
   146         -   100,                       /* szLookaside */
          146  +   128,                       /* szLookaside */
   147    147      500,                       /* nLookaside */
   148    148      {0,0,0,0,0,0,0,0},         /* m */
   149    149      {0,0,0,0,0,0,0,0,0},       /* mutex */
   150    150      {0,0,0,0,0,0,0,0,0,0,0},   /* pcache */
   151    151      (void*)0,                  /* pHeap */
   152    152      0,                         /* nHeap */
   153    153      0, 0,                      /* mnHeap, mxHeap */

Changes to src/os.c.

   204    204     const char *zFile, 
   205    205     sqlite3_file **ppFile, 
   206    206     int flags,
   207    207     int *pOutFlags
   208    208   ){
   209    209     int rc = SQLITE_NOMEM;
   210    210     sqlite3_file *pFile;
   211         -  pFile = (sqlite3_file *)sqlite3Malloc(pVfs->szOsFile);
          211  +  pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
   212    212     if( pFile ){
   213    213       rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
   214    214       if( rc!=SQLITE_OK ){
   215    215         sqlite3_free(pFile);
   216    216       }else{
   217    217         *ppFile = pFile;
   218    218       }

Changes to src/os_win.c.

  1241   1241   int sqlite3_fullsync_count = 0;
  1242   1242   #endif
  1243   1243   
  1244   1244   /*
  1245   1245   ** Make sure all writes to a particular file are committed to disk.
  1246   1246   */
  1247   1247   static int winSync(sqlite3_file *id, int flags){
  1248         -#if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || defined(SQLITE_DEBUG)
  1249         -  winFile *pFile = (winFile*)id;
         1248  +#ifndef SQLITE_NO_SYNC
         1249  +  /*
         1250  +  ** Used only when SQLITE_NO_SYNC is not defined.
         1251  +   */
  1250   1252     BOOL rc;
         1253  +#endif
         1254  +#if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || \
         1255  +    (defined(SQLITE_TEST) && defined(SQLITE_DEBUG))
         1256  +  /*
         1257  +  ** Used when SQLITE_NO_SYNC is not defined and by the assert() and/or
         1258  +  ** OSTRACE() macros.
         1259  +   */
         1260  +  winFile *pFile = (winFile*)id;
  1251   1261   #else
  1252   1262     UNUSED_PARAMETER(id);
  1253   1263   #endif
  1254   1264   
  1255   1265     assert( pFile );
  1256   1266     /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
  1257   1267     assert((flags&0x0F)==SQLITE_SYNC_NORMAL

Changes to src/pager.c.

   616    616     u8 noSync;                  /* Do not sync the journal if true */
   617    617     u8 fullSync;                /* Do extra syncs of the journal for robustness */
   618    618     u8 ckptSyncFlags;           /* SYNC_NORMAL or SYNC_FULL for checkpoint */
   619    619     u8 syncFlags;               /* SYNC_NORMAL or SYNC_FULL otherwise */
   620    620     u8 tempFile;                /* zFilename is a temporary file */
   621    621     u8 readOnly;                /* True for a read-only database */
   622    622     u8 memDb;                   /* True to inhibit all file I/O */
   623         -  u8 hasSeenStress;           /* pagerStress() called one or more times */
   624    623   
   625    624     /**************************************************************************
   626    625     ** The following block contains those class members that change during
   627    626     ** routine opertion.  Class members not in this block are either fixed
   628    627     ** when the pager is first created or else only change when there is a
   629    628     ** significant mode change (such as changing the page_size, locking_mode,
   630    629     ** or the journal_mode).  From another view, these class members describe
................................................................................
  4171   4170     ** Spilling is also prohibited when in an error state since that could
  4172   4171     ** lead to database corruption.   In the current implementaton it 
  4173   4172     ** is impossible for sqlite3PCacheFetch() to be called with createFlag==1
  4174   4173     ** while in the error state, hence it is impossible for this routine to
  4175   4174     ** be called in the error state.  Nevertheless, we include a NEVER()
  4176   4175     ** test for the error state as a safeguard against future changes.
  4177   4176     */
  4178         -  pPager->hasSeenStress = 1;
  4179   4177     if( NEVER(pPager->errCode) ) return SQLITE_OK;
  4180   4178     if( pPager->doNotSpill ) return SQLITE_OK;
  4181   4179     if( pPager->doNotSyncSpill && (pPg->flags & PGHDR_NEED_SYNC)!=0 ){
  4182   4180       return SQLITE_OK;
  4183   4181     }
  4184   4182   
  4185   4183     pPg->pDirty = 0;

Changes to src/pager.h.

    56     56   ** Allowed values for the flags parameter to sqlite3PagerOpen().
    57     57   **
    58     58   ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
    59     59   */
    60     60   #define PAGER_OMIT_JOURNAL  0x0001    /* Do not use a rollback journal */
    61     61   #define PAGER_NO_READLOCK   0x0002    /* Omit readlocks on readonly files */
    62     62   #define PAGER_MEMORY        0x0004    /* In-memory database */
    63         -#define PAGER_SORTER        0x0020    /* Accumulator in external merge sort */
    64     63   
    65     64   /*
    66     65   ** Valid values for the second argument to sqlite3PagerLockingMode().
    67     66   */
    68     67   #define PAGER_LOCKINGMODE_QUERY      -1
    69     68   #define PAGER_LOCKINGMODE_NORMAL      0
    70     69   #define PAGER_LOCKINGMODE_EXCLUSIVE   1

Changes to src/shell.c.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This file contains code to implement the "sqlite" command line
    13     13   ** utility for accessing SQLite databases.
    14     14   */
    15         -#if defined(_WIN32) || defined(WIN32)
           15  +#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
    16     16   /* This needs to come before any includes for MSVC compiler */
    17     17   #define _CRT_SECURE_NO_WARNINGS
    18     18   #endif
    19     19   
    20     20   #include <stdlib.h>
    21     21   #include <string.h>
    22     22   #include <stdio.h>

Added tool/mksqlite3c-noext.tcl.

            1  +#!/usr/bin/tclsh
            2  +#
            3  +# To build a single huge source file holding all of SQLite (or at
            4  +# least the core components - the test harness, shell, and TCL 
            5  +# interface are omitted.) first do
            6  +#
            7  +#      make target_source
            8  +#
            9  +# The make target above moves all of the source code files into
           10  +# a subdirectory named "tsrc".  (This script expects to find the files
           11  +# there and will not work if they are not found.)  There are a few
           12  +# generated C code files that are also added to the tsrc directory.
           13  +# For example, the "parse.c" and "parse.h" files to implement the
           14  +# the parser are derived from "parse.y" using lemon.  And the 
           15  +# "keywordhash.h" files is generated by a program named "mkkeywordhash".
           16  +#
           17  +# After the "tsrc" directory has been created and populated, run
           18  +# this script:
           19  +#
           20  +#      tclsh mksqlite3c.tcl
           21  +#
           22  +# The amalgamated SQLite code will be written into sqlite3.c
           23  +#
           24  +
           25  +# Begin by reading the "sqlite3.h" header file.  Extract the version number
           26  +# from in this file.  The versioon number is needed to generate the header
           27  +# comment of the amalgamation.
           28  +#
           29  +if {[lsearch $argv --nostatic]>=0} {
           30  +  set addstatic 0
           31  +} else {
           32  +  set addstatic 1
           33  +}
           34  +if {[lsearch $argv --linemacros]>=0} {
           35  +  set linemacros 1
           36  +} else {
           37  +  set linemacros 0
           38  +}
           39  +set in [open tsrc/sqlite3.h]
           40  +set cnt 0
           41  +set VERSION ?????
           42  +while {![eof $in]} {
           43  +  set line [gets $in]
           44  +  if {$line=="" && [eof $in]} break
           45  +  incr cnt
           46  +  regexp {#define\s+SQLITE_VERSION\s+"(.*)"} $line all VERSION
           47  +}
           48  +close $in
           49  +
           50  +# Open the output file and write a header comment at the beginning
           51  +# of the file.
           52  +#
           53  +set out [open sqlite3.c w]
           54  +# Force the output to use unix line endings, even on Windows.
           55  +fconfigure $out -translation lf
           56  +set today [clock format [clock seconds] -format "%Y-%m-%d %H:%M:%S UTC" -gmt 1]
           57  +puts $out [subst \
           58  +{/******************************************************************************
           59  +** This file is an amalgamation of many separate C source files from SQLite
           60  +** version $VERSION.  By combining all the individual C code files into this 
           61  +** single large file, the entire code can be compiled as a single translation
           62  +** unit.  This allows many compilers to do optimizations that would not be
           63  +** possible if the files were compiled separately.  Performance improvements
           64  +** of 5% or more are commonly seen when SQLite is compiled as a single
           65  +** translation unit.
           66  +**
           67  +** This file is all you need to compile SQLite.  To use SQLite in other
           68  +** programs, you need this file and the "sqlite3.h" header file that defines
           69  +** the programming interface to the SQLite library.  (If you do not have 
           70  +** the "sqlite3.h" header file at hand, you will find a copy embedded within
           71  +** the text of this file.  Search for "Begin file sqlite3.h" to find the start
           72  +** of the embedded sqlite3.h header file.) Additional code files may be needed
           73  +** if you want a wrapper to interface SQLite with your choice of programming
           74  +** language. The code for the "sqlite3" command-line shell is also in a
           75  +** separate file. This file contains only code for the core SQLite library.
           76  +*/
           77  +#define SQLITE_CORE 1
           78  +#define SQLITE_AMALGAMATION 1}]
           79  +if {$addstatic} {
           80  +  puts $out \
           81  +{#ifndef SQLITE_PRIVATE
           82  +# define SQLITE_PRIVATE static
           83  +#endif
           84  +#ifndef SQLITE_API
           85  +# define SQLITE_API
           86  +#endif}
           87  +}
           88  +
           89  +# These are the header files used by SQLite.  The first time any of these 
           90  +# files are seen in a #include statement in the C code, include the complete
           91  +# text of the file in-line.  The file only needs to be included once.
           92  +#
           93  +foreach hdr {
           94  +   btree.h
           95  +   btreeInt.h
           96  +   hash.h
           97  +   hwtime.h
           98  +   keywordhash.h
           99  +   mutex.h
          100  +   opcodes.h
          101  +   os_common.h
          102  +   os.h
          103  +   os_os2.h
          104  +   pager.h
          105  +   parse.h
          106  +   pcache.h
          107  +   sqlite3ext.h
          108  +   sqlite3.h
          109  +   sqliteicu.h
          110  +   sqliteInt.h
          111  +   sqliteLimit.h
          112  +   vdbe.h
          113  +   vdbeInt.h
          114  +   wal.h
          115  +} {
          116  +  set available_hdr($hdr) 1
          117  +}
          118  +set available_hdr(sqliteInt.h) 0
          119  +
          120  +# 78 stars used for comment formatting.
          121  +set s78 \
          122  +{*****************************************************************************}
          123  +
          124  +# Insert a comment into the code
          125  +#
          126  +proc section_comment {text} {
          127  +  global out s78
          128  +  set n [string length $text]
          129  +  set nstar [expr {60 - $n}]
          130  +  set stars [string range $s78 0 $nstar]
          131  +  puts $out "/************** $text $stars/"
          132  +}
          133  +
          134  +# Read the source file named $filename and write it into the
          135  +# sqlite3.c output file.  If any #include statements are seen,
          136  +# process them approprately.
          137  +#
          138  +proc copy_file {filename} {
          139  +  global seen_hdr available_hdr out addstatic linemacros
          140  +  set ln 0
          141  +  set tail [file tail $filename]
          142  +  section_comment "Begin file $tail"
          143  +  if {$linemacros} {puts $out "#line 1 \"$filename\""}
          144  +  set in [open $filename r]
          145  +  set varpattern {^[a-zA-Z][a-zA-Z_0-9 *]+(sqlite3[_a-zA-Z0-9]+)(\[|;| =)}
          146  +  set declpattern {[a-zA-Z][a-zA-Z_0-9 ]+ \**(sqlite3[_a-zA-Z0-9]+)\(}
          147  +  if {[file extension $filename]==".h"} {
          148  +    set declpattern " *$declpattern"
          149  +  }
          150  +  set declpattern ^$declpattern
          151  +  while {![eof $in]} {
          152  +    set line [gets $in]
          153  +    incr ln
          154  +    if {[regexp {^\s*#\s*include\s+["<]([^">]+)[">]} $line all hdr]} {
          155  +      if {[info exists available_hdr($hdr)]} {
          156  +        if {$available_hdr($hdr)} {
          157  +          if {$hdr!="os_common.h" && $hdr!="hwtime.h"} {
          158  +            set available_hdr($hdr) 0
          159  +          }
          160  +          section_comment "Include $hdr in the middle of $tail"
          161  +          copy_file tsrc/$hdr
          162  +          section_comment "Continuing where we left off in $tail"
          163  +          if {$linemacros} {puts $out "#line [expr {$ln+1}] \"$filename\""}
          164  +        }
          165  +      } elseif {![info exists seen_hdr($hdr)]} {
          166  +        set seen_hdr($hdr) 1
          167  +        puts $out $line
          168  +      } else {
          169  +        puts $out "/* $line */"
          170  +      }
          171  +    } elseif {[regexp {^#ifdef __cplusplus} $line]} {
          172  +      puts $out "#if 0"
          173  +    } elseif {!$linemacros && [regexp {^#line} $line]} {
          174  +      # Skip #line directives.
          175  +    } elseif {$addstatic && ![regexp {^(static|typedef)} $line]} {
          176  +      regsub {^SQLITE_API } $line {} line
          177  +      if {[regexp $declpattern $line all funcname]} {
          178  +        # Add the SQLITE_PRIVATE or SQLITE_API keyword before functions.
          179  +        # so that linkage can be modified at compile-time.
          180  +        if {[regexp {^sqlite3_} $funcname]} {
          181  +          puts $out "SQLITE_API $line"
          182  +        } else {
          183  +          puts $out "SQLITE_PRIVATE $line"
          184  +        }
          185  +      } elseif {[regexp $varpattern $line all varname]} {
          186  +        # Add the SQLITE_PRIVATE before variable declarations or
          187  +        # definitions for internal use
          188  +        if {![regexp {^sqlite3_} $varname]} {
          189  +          regsub {^extern } $line {} line
          190  +          puts $out "SQLITE_PRIVATE $line"
          191  +        } else {
          192  +          if {[regexp {const char sqlite3_version\[\];} $line]} {
          193  +            set line {const char sqlite3_version[] = SQLITE_VERSION;}
          194  +          }
          195  +          regsub {^SQLITE_EXTERN } $line {} line
          196  +          puts $out "SQLITE_API $line"
          197  +        }
          198  +      } elseif {[regexp {^(SQLITE_EXTERN )?void \(\*sqlite3IoTrace\)} $line]} {
          199  +        regsub {^SQLITE_EXTERN } $line {} line
          200  +        puts $out "SQLITE_PRIVATE $line"
          201  +      } elseif {[regexp {^void \(\*sqlite3Os} $line]} {
          202  +        puts $out "SQLITE_PRIVATE $line"
          203  +      } else {
          204  +        puts $out $line
          205  +      }
          206  +    } else {
          207  +      puts $out $line
          208  +    }
          209  +  }
          210  +  close $in
          211  +  section_comment "End of $tail"
          212  +}
          213  +
          214  +
          215  +# Process the source files.  Process files containing commonly
          216  +# used subroutines first in order to help the compiler find
          217  +# inlining opportunities.
          218  +#
          219  +foreach file {
          220  +   sqliteInt.h
          221  +
          222  +   global.c
          223  +   ctime.c
          224  +   status.c
          225  +   date.c
          226  +   os.c
          227  +
          228  +   fault.c
          229  +   mem0.c
          230  +   mem1.c
          231  +   mem2.c
          232  +   mem3.c
          233  +   mem5.c
          234  +   mutex.c
          235  +   mutex_noop.c
          236  +   mutex_os2.c
          237  +   mutex_unix.c
          238  +   mutex_w32.c
          239  +   malloc.c
          240  +   printf.c
          241  +   random.c
          242  +   utf.c
          243  +   util.c
          244  +   hash.c
          245  +   opcodes.c
          246  +
          247  +   os_os2.c
          248  +   os_unix.c
          249  +   os_win.c
          250  +
          251  +   bitvec.c
          252  +   pcache.c
          253  +   pcache1.c
          254  +   rowset.c
          255  +   pager.c
          256  +   wal.c
          257  +
          258  +   btmutex.c
          259  +   btree.c
          260  +   backup.c
          261  +
          262  +   vdbemem.c
          263  +   vdbeaux.c
          264  +   vdbeapi.c
          265  +   vdbetrace.c
          266  +   vdbe.c
          267  +   vdbeblob.c
          268  +   vdbesort.c
          269  +   journal.c
          270  +   memjournal.c
          271  +
          272  +   walker.c
          273  +   resolve.c
          274  +   expr.c
          275  +   alter.c
          276  +   analyze.c
          277  +   attach.c
          278  +   auth.c
          279  +   build.c
          280  +   callback.c
          281  +   delete.c
          282  +   func.c
          283  +   fkey.c
          284  +   insert.c
          285  +   legacy.c
          286  +   loadext.c
          287  +   pragma.c
          288  +   prepare.c
          289  +   select.c
          290  +   table.c
          291  +   trigger.c
          292  +   update.c
          293  +   vacuum.c
          294  +   vtab.c
          295  +   where.c
          296  +
          297  +   parse.c
          298  +
          299  +   tokenize.c
          300  +   complete.c
          301  +
          302  +   main.c
          303  +   notify.c
          304  +} {
          305  +  copy_file tsrc/$file
          306  +}
          307  +
          308  +close $out