sqllogictest
Check-in [d202f9faa0]
Not logged in

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

Overview
Comment:Update SQLite to CVS check-in 6031.
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: d202f9faa04f5c70e5c12d26cea0387a6f8c2c69
User & Date: drh 2008-12-16 13:55:34
Context
2008-12-22
21:23
Merged in the SQLite amalgamation update. check-in: d3b0d1eea2 user: drh tags: trunk
2008-12-16
13:55
Update SQLite to CVS check-in 6031. check-in: d202f9faa0 user: drh tags: trunk
2008-12-11
05:16
Test cases for SQLite, MSSQL, and MySQL stressing GROUP BY, HAVING, and aggregate functions. check-in: e3edcb9099 user: shaneh tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to src/sqlite3.c.

more than 10,000 changes

Changes to src/sqlite3.h.

    26     26   ** on how SQLite interfaces are suppose to operate.
    27     27   **
    28     28   ** The name of this file under configuration management is "sqlite.h.in".
    29     29   ** The makefile makes some minor changes to this file (such as inserting
    30     30   ** the version number) and changes its name to "sqlite3.h" as
    31     31   ** part of the build process.
    32     32   **
    33         -** @(#) $Id: sqlite.h.in,v 1.415 2008/11/19 01:20:26 drh Exp $
           33  +** @(#) $Id: sqlite.h.in,v 1.420 2008/12/16 13:46:30 drh Exp $
    34     34   */
    35     35   #ifndef _SQLITE3_H_
    36     36   #define _SQLITE3_H_
    37     37   #include <stdarg.h>     /* Needed for the definition of va_list */
    38     38   
    39     39   /*
    40     40   ** Make sure we can call this stuff from C++.
................................................................................
   103    103   **          evaluate to a string literal that is the SQLite version
   104    104   **          with which the header file is associated.
   105    105   **
   106    106   ** {H10014} The SQLITE_VERSION_NUMBER #define shall resolve to an integer
   107    107   **          with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z
   108    108   **          are the major version, minor version, and release number.
   109    109   */
   110         -#define SQLITE_VERSION         "3.6.6.2"
   111         -#define SQLITE_VERSION_NUMBER  3006006
          110  +#define SQLITE_VERSION         "3.6.7"
          111  +#define SQLITE_VERSION_NUMBER  3006007
   112    112   
   113    113   /*
   114    114   ** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>
   115    115   ** KEYWORDS: sqlite3_version
   116    116   **
   117    117   ** These features provide the same information as the [SQLITE_VERSION]
   118    118   ** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated
................................................................................
   503    503   #define SQLITE_IOERR_RDLOCK            (SQLITE_IOERR | (9<<8))
   504    504   #define SQLITE_IOERR_DELETE            (SQLITE_IOERR | (10<<8))
   505    505   #define SQLITE_IOERR_BLOCKED           (SQLITE_IOERR | (11<<8))
   506    506   #define SQLITE_IOERR_NOMEM             (SQLITE_IOERR | (12<<8))
   507    507   #define SQLITE_IOERR_ACCESS            (SQLITE_IOERR | (13<<8))
   508    508   #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
   509    509   #define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
          510  +#define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
          511  +#define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
   510    512   
   511    513   /*
   512    514   ** CAPI3REF: Flags For File Open Operations {H10230} <H11120> <H12700>
   513    515   **
   514    516   ** These bit values are intended for use in the
   515    517   ** 3rd parameter to the [sqlite3_open_v2()] interface and
   516    518   ** in the 4th parameter to the xOpen method of the
................................................................................
   719    721   ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
   720    722   ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
   721    723   ** into an integer that the pArg argument points to. This capability
   722    724   ** is used during testing and only needs to be supported when SQLITE_TEST
   723    725   ** is defined.
   724    726   */
   725    727   #define SQLITE_FCNTL_LOCKSTATE        1
          728  +#define SQLITE_GET_LOCKPROXYFILE      2
          729  +#define SQLITE_SET_LOCKPROXYFILE      3
          730  +#define SQLITE_LAST_ERRNO             4
   726    731   
   727    732   /*
   728    733   ** CAPI3REF: Mutex Handle {H17110} <S20130>
   729    734   **
   730    735   ** The mutex module within SQLite defines [sqlite3_mutex] to be an
   731    736   ** abstract type for a mutex object.  The SQLite core never looks
   732    737   ** at the internal representation of an [sqlite3_mutex].  It only
................................................................................
   766    771   ** or modify this field while holding a particular static mutex.
   767    772   ** The application should never modify anything within the sqlite3_vfs
   768    773   ** object once the object has been registered.
   769    774   **
   770    775   ** The zName field holds the name of the VFS module.  The name must
   771    776   ** be unique across all VFS modules.
   772    777   **
   773         -** {H11141} SQLite will guarantee that the zFilename parameter to xOpen
          778  +** SQLite will guarantee that the zFilename parameter to xOpen
   774    779   ** is either a NULL pointer or string obtained
   775    780   ** from xFullPathname().  SQLite further guarantees that
   776    781   ** the string will be valid and unchanged until xClose() is
   777         -** called. {END}  Because of the previous sentense,
          782  +** called. Because of the previous sentense,
   778    783   ** the [sqlite3_file] can safely store a pointer to the
   779    784   ** filename if it needs to remember the filename for some reason.
   780    785   ** If the zFilename parameter is xOpen is a NULL pointer then xOpen
   781    786   ** must invite its own temporary name for the file.  Whenever the 
   782    787   ** xFilename parameter is NULL it will also be the case that the
   783    788   ** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
   784    789   **
   785         -** {H11142} The flags argument to xOpen() includes all bits set in
          790  +** The flags argument to xOpen() includes all bits set in
   786    791   ** the flags argument to [sqlite3_open_v2()].  Or if [sqlite3_open()]
   787    792   ** or [sqlite3_open16()] is used, then flags includes at least
   788         -** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. {END}
          793  +** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. 
   789    794   ** If xOpen() opens a file read-only then it sets *pOutFlags to
   790    795   ** include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be set.
   791    796   **
   792         -** {H11143} SQLite will also add one of the following flags to the xOpen()
          797  +** SQLite will also add one of the following flags to the xOpen()
   793    798   ** call, depending on the object being opened:
   794    799   **
   795    800   ** <ul>
   796    801   ** <li>  [SQLITE_OPEN_MAIN_DB]
   797    802   ** <li>  [SQLITE_OPEN_MAIN_JOURNAL]
   798    803   ** <li>  [SQLITE_OPEN_TEMP_DB]
   799    804   ** <li>  [SQLITE_OPEN_TEMP_JOURNAL]
   800    805   ** <li>  [SQLITE_OPEN_TRANSIENT_DB]
   801    806   ** <li>  [SQLITE_OPEN_SUBJOURNAL]
   802    807   ** <li>  [SQLITE_OPEN_MASTER_JOURNAL]
   803         -** </ul> {END}
          808  +** </ul>
   804    809   **
   805    810   ** The file I/O implementation can use the object type flags to
   806    811   ** change the way it deals with files.  For example, an application
   807    812   ** that does not care about crash recovery or rollback might make
   808    813   ** the open of a journal file a no-op.  Writes to this journal would
   809    814   ** also be no-ops, and any attempt to read the journal would return
   810    815   ** SQLITE_IOERR.  Or the implementation might recognize that a database
................................................................................
   814    819   ** SQLite might also add one of the following flags to the xOpen method:
   815    820   **
   816    821   ** <ul>
   817    822   ** <li> [SQLITE_OPEN_DELETEONCLOSE]
   818    823   ** <li> [SQLITE_OPEN_EXCLUSIVE]
   819    824   ** </ul>
   820    825   **
   821         -** {H11145} The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
   822         -** deleted when it is closed.  {H11146} The [SQLITE_OPEN_DELETEONCLOSE]
          826  +** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
          827  +** deleted when it is closed.  The [SQLITE_OPEN_DELETEONCLOSE]
   823    828   ** will be set for TEMP  databases, journals and for subjournals.
   824    829   **
   825         -** {H11147} The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened
          830  +** The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened
   826    831   ** for exclusive access.  This flag is set for all files except
   827    832   ** for the main database file.
   828    833   **
   829         -** {H11148} At least szOsFile bytes of memory are allocated by SQLite
          834  +** At least szOsFile bytes of memory are allocated by SQLite
   830    835   ** to hold the  [sqlite3_file] structure passed as the third
   831         -** argument to xOpen. {END}  The xOpen method does not have to
          836  +** argument to xOpen.  The xOpen method does not have to
   832    837   ** allocate the structure; it should just fill it in.
   833    838   **
   834         -** {H11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
          839  +** The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
   835    840   ** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to
   836    841   ** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]
   837         -** to test whether a file is at least readable. {END}  The file can be a
          842  +** to test whether a file is at least readable.   The file can be a
   838    843   ** directory.
   839    844   **
   840         -** {H11150} SQLite will always allocate at least mxPathname+1 bytes for the
   841         -** output buffer xFullPathname. {H11151} The exact size of the output buffer
   842         -** is also passed as a parameter to both  methods. {END}  If the output buffer
          845  +** SQLite will always allocate at least mxPathname+1 bytes for the
          846  +** output buffer xFullPathname.  The exact size of the output buffer
          847  +** is also passed as a parameter to both  methods. If the output buffer
   843    848   ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
   844    849   ** handled as a fatal error by SQLite, vfs implementations should endeavor
   845    850   ** to prevent this by setting mxPathname to a sufficiently large value.
   846    851   **
   847    852   ** The xRandomness(), xSleep(), and xCurrentTime() interfaces
   848    853   ** are not strictly a part of the filesystem, but they are
   849    854   ** included in the VFS structure for completeness.
   850    855   ** The xRandomness() function attempts to return nBytes bytes
   851    856   ** of good-quality randomness into zOut.  The return value is
   852    857   ** the actual number of bytes of randomness obtained.
   853    858   ** The xSleep() method causes the calling thread to sleep for at
   854    859   ** least the number of microseconds given.  The xCurrentTime()
   855    860   ** method returns a Julian Day Number for the current date and time.
          861  +**
   856    862   */
   857    863   typedef struct sqlite3_vfs sqlite3_vfs;
   858    864   struct sqlite3_vfs {
   859    865     int iVersion;            /* Structure version number */
   860    866     int szOsFile;            /* Size of subclassed sqlite3_file */
   861    867     int mxPathname;          /* Maximum file pathname length */
   862    868     sqlite3_vfs *pNext;      /* Next registered VFS */
................................................................................
   865    871     int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
   866    872                  int flags, int *pOutFlags);
   867    873     int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
   868    874     int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
   869    875     int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
   870    876     void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
   871    877     void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
   872         -  void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol);
          878  +  void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
   873    879     void (*xDlClose)(sqlite3_vfs*, void*);
   874    880     int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
   875    881     int (*xSleep)(sqlite3_vfs*, int microseconds);
   876    882     int (*xCurrentTime)(sqlite3_vfs*, double*);
   877    883     int (*xGetLastError)(sqlite3_vfs*, int, char *);
   878    884     /* New fields may be appended in figure versions.  The iVersion
   879    885     ** value will increment whenever this happens. */
   880    886   };
   881    887   
   882    888   /*
   883    889   ** CAPI3REF: Flags for the xAccess VFS method {H11190} <H11140>
   884    890   **
   885         -** {H11191} These integer constants can be used as the third parameter to
          891  +** These integer constants can be used as the third parameter to
   886    892   ** the xAccess method of an [sqlite3_vfs] object. {END}  They determine
   887    893   ** what kind of permissions the xAccess method is looking for.
   888         -** {H11192} With SQLITE_ACCESS_EXISTS, the xAccess method
          894  +** With SQLITE_ACCESS_EXISTS, the xAccess method
   889    895   ** simply checks whether the file exists.
   890         -** {H11193} With SQLITE_ACCESS_READWRITE, the xAccess method
          896  +** With SQLITE_ACCESS_READWRITE, the xAccess method
   891    897   ** checks whether the file is both readable and writable.
   892         -** {H11194} With SQLITE_ACCESS_READ, the xAccess method
          898  +** With SQLITE_ACCESS_READ, the xAccess method
   893    899   ** checks whether the file is readable.
   894    900   */
   895    901   #define SQLITE_ACCESS_EXISTS    0
   896    902   #define SQLITE_ACCESS_READWRITE 1
   897    903   #define SQLITE_ACCESS_READ      2
   898    904   
   899    905   /*
................................................................................
  1040   1046   **          enabled by default.
  1041   1047   **
  1042   1048   ** {H14150} A successful call to [sqlite3_config]([SQLITE_CONFIG_SCRATCH],S,Z,N)
  1043   1049   **          where Z and N are non-negative integers and 
  1044   1050   **          S is a pointer to an aligned memory buffer not less than
  1045   1051   **          Z*N bytes in size shall cause S to be used by the
  1046   1052   **          [scratch memory allocator] for as many as N simulataneous
  1047         -**          allocations each of size Z.
         1053  +**          allocations each of size (Z & ~7).
  1048   1054   **
  1049   1055   ** {H14153} A successful call to [sqlite3_config]([SQLITE_CONFIG_SCRATCH],S,Z,N)
  1050   1056   **          where S is a NULL pointer shall disable the
  1051   1057   **          [scratch memory allocator].
  1052   1058   **
  1053   1059   ** {H14156} A successful call to
  1054   1060   **          [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],S,Z,N)
  1055   1061   **          where Z and N are non-negative integers and 
  1056   1062   **          S is a pointer to an aligned memory buffer not less than
  1057   1063   **          Z*N bytes in size shall cause S to be used by the
  1058   1064   **          [pagecache memory allocator] for as many as N simulataneous
  1059         -**          allocations each of size Z.
         1065  +**          allocations each of size (Z & ~7).
  1060   1066   **
  1061   1067   ** {H14159} A successful call to
  1062   1068   **          [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],S,Z,N)
  1063   1069   **          where S is a NULL pointer shall disable the
  1064   1070   **          [pagecache memory allocator].
  1065   1071   **
  1066   1072   ** {H14162} A successful call to [sqlite3_config]([SQLITE_CONFIG_HEAP],H,Z,N)
................................................................................
  1400   1406   */
  1401   1407   int sqlite3_extended_result_codes(sqlite3*, int onoff);
  1402   1408   
  1403   1409   /*
  1404   1410   ** CAPI3REF: Last Insert Rowid {H12220} <S10700>
  1405   1411   **
  1406   1412   ** Each entry in an SQLite table has a unique 64-bit signed
  1407         -** integer key called the "rowid". The rowid is always available
         1413  +** integer key called the [ROWID | "rowid"]. The rowid is always available
  1408   1414   ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
  1409   1415   ** names are not also used by explicitly declared columns. If
  1410         -** the table has a column of type INTEGER PRIMARY KEY then that column
         1416  +** the table has a column of type [INTEGER PRIMARY KEY] then that column
  1411   1417   ** is another alias for the rowid.
  1412   1418   **
  1413         -** This routine returns the rowid of the most recent
         1419  +** This routine returns the [rowid] of the most recent
  1414   1420   ** successful [INSERT] into the database from the [database connection]
  1415   1421   ** in the first argument.  If no successful [INSERT]s
  1416   1422   ** have ever occurred on that database connection, zero is returned.
  1417   1423   **
  1418         -** If an [INSERT] occurs within a trigger, then the rowid of the inserted
         1424  +** If an [INSERT] occurs within a trigger, then the [rowid] of the inserted
  1419   1425   ** row is returned by this routine as long as the trigger is running.
  1420   1426   ** But once the trigger terminates, the value returned by this routine
  1421   1427   ** reverts to the last value inserted before the trigger fired.
  1422   1428   **
  1423   1429   ** An [INSERT] that fails due to a constraint violation is not a
  1424   1430   ** successful [INSERT] and does not change the value returned by this
  1425   1431   ** routine.  Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
................................................................................
  1431   1437   ** the return value of this interface.
  1432   1438   **
  1433   1439   ** For the purposes of this routine, an [INSERT] is considered to
  1434   1440   ** be successful even if it is subsequently rolled back.
  1435   1441   **
  1436   1442   ** INVARIANTS:
  1437   1443   **
  1438         -** {H12221} The [sqlite3_last_insert_rowid()] function shall return the rowid
         1444  +** {H12221} The [sqlite3_last_insert_rowid()] function shall return
         1445  +**          the [rowid]
  1439   1446   **          of the most recent successful [INSERT] performed on the same
  1440   1447   **          [database connection] and within the same or higher level
  1441   1448   **          trigger context, or zero if there have been no qualifying
  1442   1449   **          [INSERT] statements.
  1443   1450   **
  1444   1451   ** {H12223} The [sqlite3_last_insert_rowid()] function shall return the
  1445   1452   **          same value when called from the same trigger context
  1446   1453   **          immediately before and after a [ROLLBACK].
  1447   1454   **
  1448   1455   ** ASSUMPTIONS:
  1449   1456   **
  1450   1457   ** {A12232} If a separate thread performs a new [INSERT] on the same
  1451   1458   **          database connection while the [sqlite3_last_insert_rowid()]
  1452         -**          function is running and thus changes the last insert rowid,
         1459  +**          function is running and thus changes the last insert [rowid],
  1453   1460   **          then the value returned by [sqlite3_last_insert_rowid()] is
  1454   1461   **          unpredictable and might not equal either the old or the new
  1455         -**          last insert rowid.
         1462  +**          last insert [rowid].
  1456   1463   */
  1457   1464   sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
  1458   1465   
  1459   1466   /*
  1460   1467   ** CAPI3REF: Count The Number Of Rows Modified {H12240} <S10600>
  1461   1468   **
  1462   1469   ** This function returns the number of database rows that were changed
................................................................................
  2159   2166   sqlite3_int64 sqlite3_memory_used(void);
  2160   2167   sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
  2161   2168   
  2162   2169   /*
  2163   2170   ** CAPI3REF: Pseudo-Random Number Generator {H17390} <S20000>
  2164   2171   **
  2165   2172   ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
  2166         -** select random ROWIDs when inserting new records into a table that
  2167         -** already uses the largest possible ROWID.  The PRNG is also used for
         2173  +** select random [ROWID | ROWIDs] when inserting new records into a table that
         2174  +** already uses the largest possible [ROWID].  The PRNG is also used for
  2168   2175   ** the build-in random() and randomblob() SQL functions.  This interface allows
  2169   2176   ** applications to access the same PRNG for other purposes.
  2170   2177   **
  2171   2178   ** A call to this routine stores N bytes of randomness into buffer P.
  2172   2179   **
  2173   2180   ** The first time this routine is invoked (either internally or by
  2174   2181   ** the application) the PRNG is seeded using randomness obtained
................................................................................
  5109   5116   ** The first argument to the callback is a copy of the third argument
  5110   5117   ** to sqlite3_update_hook().
  5111   5118   ** The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE],
  5112   5119   ** or [SQLITE_UPDATE], depending on the operation that caused the callback
  5113   5120   ** to be invoked.
  5114   5121   ** The third and fourth arguments to the callback contain pointers to the
  5115   5122   ** database and table name containing the affected row.
  5116         -** The final callback parameter is the rowid of the row. In the case of
  5117         -** an update, this is the rowid after the update takes place.
         5123  +** The final callback parameter is the [rowid] of the row.
         5124  +** In the case of an update, this is the [rowid] after the update takes place.
  5118   5125   **
  5119   5126   ** The update hook is not invoked when internal system tables are
  5120   5127   ** modified (i.e. sqlite_master and sqlite_sequence).
  5121   5128   **
  5122   5129   ** The update hook implementation must not do anything that will modify
  5123   5130   ** the database connection that invoked the update hook.  Any actions
  5124   5131   ** to modify the database connection must be deferred until after the
................................................................................
  5153   5160   **          is one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE],
  5154   5161   **          depending on the operation that caused the callback to be invoked.
  5155   5162   **
  5156   5163   ** {H12983} The third and fourth arguments to the callback contain pointers
  5157   5164   **          to zero-terminated UTF-8 strings which are the names of the
  5158   5165   **          database and table that is being updated.
  5159   5166   
  5160         -** {H12985} The final callback parameter is the rowid of the row after
         5167  +** {H12985} The final callback parameter is the [rowid] of the row after
  5161   5168   **          the change occurs.
  5162   5169   */
  5163   5170   void *sqlite3_update_hook(
  5164   5171     sqlite3*, 
  5165   5172     void(*)(void *,int ,char const *,char const *,sqlite3_int64),
  5166   5173     void*
  5167   5174   );
................................................................................
  5319   5326   ** <table border="1">
  5320   5327   ** <tr><th> Parameter <th> Output<br>Type <th>  Description
  5321   5328   **
  5322   5329   ** <tr><td> 5th <td> const char* <td> Data type
  5323   5330   ** <tr><td> 6th <td> const char* <td> Name of default collation sequence
  5324   5331   ** <tr><td> 7th <td> int         <td> True if column has a NOT NULL constraint
  5325   5332   ** <tr><td> 8th <td> int         <td> True if column is part of the PRIMARY KEY
  5326         -** <tr><td> 9th <td> int         <td> True if column is AUTOINCREMENT
         5333  +** <tr><td> 9th <td> int         <td> True if column is [AUTOINCREMENT]
  5327   5334   ** </table>
  5328   5335   ** </blockquote>
  5329   5336   **
  5330   5337   ** The memory pointed to by the character pointers returned for the
  5331   5338   ** declaration type and collation sequence is valid only until the next
  5332   5339   ** call to any SQLite API function.
  5333   5340   **
  5334   5341   ** If the specified table is actually a view, an [error code] is returned.
  5335   5342   **
  5336   5343   ** If the specified column is "rowid", "oid" or "_rowid_" and an
  5337         -** INTEGER PRIMARY KEY column has been explicitly declared, then the output
         5344  +** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
  5338   5345   ** parameters are set for the explicitly declared column. If there is no
  5339         -** explicitly declared INTEGER PRIMARY KEY column, then the output
         5346  +** explicitly declared [INTEGER PRIMARY KEY] column, then the output
  5340   5347   ** parameters are set as follows:
  5341   5348   **
  5342   5349   ** <pre>
  5343   5350   **     data type: "INTEGER"
  5344   5351   **     collation sequence: "BINARY"
  5345   5352   **     not null: 0
  5346   5353   **     primary key: 1
................................................................................
  5439   5446   **          multiple times with the same extension is harmless.
  5440   5447   **
  5441   5448   ** {H12643} This routine stores a pointer to the extension in an array
  5442   5449   **          that is obtained from [sqlite3_malloc()].
  5443   5450   **
  5444   5451   ** {H12644} Automatic extensions apply across all threads.
  5445   5452   */
  5446         -int sqlite3_auto_extension(void *xEntryPoint);
         5453  +int sqlite3_auto_extension(void (*xEntryPoint)(void));
  5447   5454   
  5448   5455   /*
  5449   5456   ** CAPI3REF: Reset Automatic Extension Loading {H12660} <S20500>
  5450   5457   **
  5451   5458   ** This function disables all previously registered automatic
  5452   5459   ** extensions. {END}  It undoes the effect of all prior
  5453   5460   ** [sqlite3_auto_extension()] calls.
................................................................................
  5756   5763   ** CAPI3REF: Open A BLOB For Incremental I/O {H17810} <S30230>
  5757   5764   **
  5758   5765   ** This interfaces opens a [BLOB handle | handle] to the BLOB located
  5759   5766   ** in row iRow, column zColumn, table zTable in database zDb;
  5760   5767   ** in other words, the same BLOB that would be selected by:
  5761   5768   **
  5762   5769   ** <pre>
  5763         -**     SELECT zColumn FROM zDb.zTable WHERE rowid = iRow;
         5770  +**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
  5764   5771   ** </pre> {END}
  5765   5772   **
  5766   5773   ** If the flags parameter is non-zero, the the BLOB is opened for read
  5767   5774   ** and write access. If it is zero, the BLOB is opened for read access.
  5768   5775   **
  5769   5776   ** Note that the database name is not the filename that contains
  5770   5777   ** the database but rather the symbolic name of the database that