Automated update from Qt3

14 files changed, 51 insertions, 51 deletions

diff --git a/src/3rdparty/sqlite/btree.c b/src/3rdparty/sqlite/btree.c
index c5f077ab3..6b9c6b021 100644
--- a/src/3rdparty/sqlite/btree.c
+++ b/src/3rdparty/sqlite/btree.c
@@ -308,7 +308,7 @@ struct FreelistInfo {
 ** than can possibly fit on one page.  In the steady state, every apCell[]
 ** points to memory inside u.aDisk[].  But in the middle of an insert
 ** operation, some apCell[] entries may temporarily point to data space
-** outside of u.aDisk[].  This is a transient situation that is tquickly
+** outside of u.aDisk[].  This is a transient situation that is quickly
 ** resolved.  But while it is happening, it is possible for a database
 ** page to hold as many as two more cells than it might otherwise hold.
 ** The extra two entries in apCell[] are an allowance for this situation.
@@ -772,7 +772,7 @@ static int fileBtreeSetSafetyLevel(Btree *pBt, int level){
 
 /*
 ** Get a reference to page1 of the database file.  This will
-** also actquire a readlock on that file.
+** also acquire a readlock on that file.
 **
 ** SQLITE_OK is returned on success.  If the file is not a
 ** well-formed database file, then SQLITE_CORRUPT is returned.
@@ -997,7 +997,7 @@ static int fileBtreeRollbackCkpt(Btree *pBt){
 
 /*
 ** Create a new cursor for the BTree whose root is on the page
-** iTable.  The act of actquiring a cursor gets a read lock on 
+** iTable.  The act of acquiring a cursor gets a read lock on 
 ** the database file.
 **
 ** If wrFlag==0, then the cursor can only be used for reading.
@@ -1028,7 +1028,7 @@ static int fileBtreeRollbackCkpt(Btree *pBt){
 ** to write.
 ** 
 ** No checking is done to make sure that page iTable really is the
-** root page of a b-tree.  If it is not, then the cursor actquired
+** root page of a b-tree.  If it is not, then the cursor acquired
 ** will not work correctly.
 */
 static int fileBtreeCursor(Btree *pBt, int iTable, int wrFlag, BtCursor **ppCur){
@@ -3423,7 +3423,7 @@ char *fileBtreeIntegrityCheck(Btree *pBt, int *aRoot, int nRoot){
 
   nRef = *sqlitepager_stats(pBt->pPager);
   if( lockBtree(pBt)!=SQLITE_OK ){
-    return sqliteStrDup("Unable to actquire a read lock on the database");
+    return sqliteStrDup("Unable to acquire a read lock on the database");
   }
   sCheck.pBt = pBt;
   sCheck.pPager = pBt->pPager;
diff --git a/src/3rdparty/sqlite/build.c b/src/3rdparty/sqlite/build.c
index 2639604b3..87c88346b 100644
--- a/src/3rdparty/sqlite/build.c
+++ b/src/3rdparty/sqlite/build.c
@@ -527,7 +527,7 @@ void sqliteStartTable(
   /* Begin generating the code that will insert the table record into
   ** the SQLITE_MASTER table.  Note in particular that we must go ahead
   ** and allocate the record number for the table entry now.  Before any
-  ** PRIMARY KEY or UNITQUE keywords are parsed.  Those keywords will cause
+  ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause
   ** indices to be created and the table record must come before the 
   ** indices.  Hence, the record number for the table must be allocated
   ** now.
@@ -1462,7 +1462,7 @@ void sqliteDeferForeignKey(Parse *pParse, int isDeferred){
 ** Create a new index for an SQL table.  pIndex is the name of the index 
 ** and pTable is the name of the table that is to be indexed.  Both will 
 ** be NULL for a primary key or an index that is created to satisfy a
-** UNITQUE constraint.  If pTable and pIndex are NULL, use pParse->pNewTable
+** UNIQUE constraint.  If pTable and pIndex are NULL, use pParse->pNewTable
 ** as the table to be indexed.  pParse->pNewTable is a table that is
 ** currently being constructed by a CREATE TABLE statement.
 **
@@ -1532,7 +1532,7 @@ void sqliteCreateIndex(
   ** index, then we will continue to process this index.
   **
   ** If pName==0 it means that we are
-  ** dealing with a primary key or UNITQUE constraint.  We have to invent our
+  ** dealing with a primary key or UNIQUE constraint.  We have to invent our
   ** own name.
   */
   if( pName && !db->init.busy ){
@@ -1674,7 +1674,7 @@ void sqliteCreateIndex(
   ** we don't want to recreate it.
   **
   ** If pTable==0 it means this index is generated as a primary key
-  ** or UNITQUE constraint of a CREATE TABLE statement.  Since the table
+  ** or UNIQUE constraint of a CREATE TABLE statement.  Since the table
   ** has just been created, it contains no data and the index initialization
   ** step can be skipped.
   */
@@ -1768,7 +1768,7 @@ void sqliteDropIndex(Parse *pParse, SrcList *pName){
     goto exit_drop_index;
   }
   if( pIndex->autoIndex ){
-    sqliteErrorMsg(pParse, "index associated with UNITQUE "
+    sqliteErrorMsg(pParse, "index associated with UNIQUE "
       "or PRIMARY KEY constraint cannot be dropped", 0);
     goto exit_drop_index;
   }
diff --git a/src/3rdparty/sqlite/insert.c b/src/3rdparty/sqlite/insert.c
index 5957f3005..64e18ba05 100644
--- a/src/3rdparty/sqlite/insert.c
+++ b/src/3rdparty/sqlite/insert.c
@@ -567,7 +567,7 @@ insert_cleanup:
 ** aIdxUsed!=0 and aIdxUsed[i]!=0.
 **
 ** This routine also generates code to check constraints.  NOT NULL,
-** CHECK, and UNITQUE constraints are all checked.  If a constraint fails,
+** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,
 ** then the appropriate action is performed.  There are five possible
 ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
 **
@@ -595,7 +595,7 @@ insert_cleanup:
 **                                value for that column.  If the default value
 **                                is NULL, the action is the same as ABORT.
 **
-**  UNITQUE           REPLACE      The other row that conflicts with the row
+**  UNIQUE           REPLACE      The other row that conflicts with the row
 **                                being inserted is removed.
 **
 **  CHECK            REPLACE      Illegal.  The results in an exception.
@@ -753,7 +753,7 @@ void sqliteGenerateConstraintChecks(
     }
   }
 
-  /* Test all UNITQUE constraints by creating entries for each UNITQUE
+  /* Test all UNIQUE constraints by creating entries for each UNIQUE
   ** index and making sure that duplicate entries do not already exist.
   ** Add the new records to the indices as we go.
   */
@@ -777,7 +777,7 @@ void sqliteGenerateConstraintChecks(
 
     /* Find out what action to take in case there is an indexing conflict */
     onError = pIdx->onError;
-    if( onError==OE_None ) continue;  /* pIdx is not a UNITQUE index */
+    if( onError==OE_None ) continue;  /* pIdx is not a UNIQUE index */
     if( overrideError!=OE_Default ){
       onError = overrideError;
     }else if( pParse->db->onError!=OE_Default ){
@@ -843,7 +843,7 @@ void sqliteGenerateConstraintChecks(
       default: assert(0);
     }
     contAddr = sqliteVdbeCurrentAddr(v);
-#if NULL_DISTINCT_FOR_UNITQUE
+#if NULL_DISTINCT_FOR_UNIQUE
     sqliteVdbeChangeP2(v, jumpInst1, contAddr);
 #endif
     sqliteVdbeChangeP2(v, jumpInst2, contAddr);
diff --git a/src/3rdparty/sqlite/main.c b/src/3rdparty/sqlite/main.c
index 725b6503e..6fa014104 100644
--- a/src/3rdparty/sqlite/main.c
+++ b/src/3rdparty/sqlite/main.c
@@ -90,7 +90,7 @@ int sqliteInitCallback(void *pInit, int argc, char **argv, char **azColName){
         db->init.iDb = 0;
       }else{
         /* If the SQL column is blank it means this is an index that
-        ** was created to be the PRIMARY KEY or to fulfill a UNITQUE
+        ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
         ** constraint for a CREATE TABLE.  The index should have already
         ** been created when we processed the CREATE TABLE.  All we have
         ** to do here is record the root page number for that index.
diff --git a/src/3rdparty/sqlite/os.c b/src/3rdparty/sqlite/os.c
index 3130bdeeb..b4ae7a107 100644
--- a/src/3rdparty/sqlite/os.c
+++ b/src/3rdparty/sqlite/os.c
@@ -1245,7 +1245,7 @@ int isNT(void){
 ** A database write lock is obtained by locking all bytes in the range.
 ** There can only be one writer.
 **
-** A lock is obtained on the first byte of the lock range before actquiring
+** A lock is obtained on the first byte of the lock range before acquiring
 ** either a read lock or a write lock.  This prevents two processes from
 ** attempting to get a lock at a same time.  The semantics of 
 ** sqliteOsReadLock() require that if there is already a write lock, that
@@ -1280,7 +1280,7 @@ int isNT(void){
 /*
 ** Change the status of the lock on the file "id" to be a readlock.
 ** If the file was write locked, then this reduces the lock to a read.
-** If the file was read locked, then this actquires a new read lock.
+** If the file was read locked, then this acquires a new read lock.
 **
 ** Return SQLITE_OK on success and SQLITE_BUSY on failure.  If this
 ** library was compiled with large file support (LFS) but LFS is not
@@ -1685,7 +1685,7 @@ static int inMutex = 0;
 ** executed code that is surrounded by EnterMutex() and LeaveMutex().
 **
 ** SQLite uses only a single Mutex.  There is not much critical
-** code and what little there is executes tquickly and without blocking.
+** code and what little there is executes quickly and without blocking.
 */
 void sqliteOsEnterMutex(){
 #ifdef SQLITE_UNIX_THREADS
diff --git a/src/3rdparty/sqlite/pager.c b/src/3rdparty/sqlite/pager.c
index 32dcf19b2..8b6a15465 100644
--- a/src/3rdparty/sqlite/pager.c
+++ b/src/3rdparty/sqlite/pager.c
@@ -463,7 +463,7 @@ static void pager_reset(Pager *pPager){
 /*
 ** When this routine is called, the pager has the journal file open and
 ** a write lock on the database.  This routine releases the database
-** write lock and actquires a read lock in its place.  The journal file
+** write lock and acquires a read lock in its place.  The journal file
 ** is deleted and closed.
 **
 ** TODO: Consider keeping the journal file open for temporary databases.
@@ -1286,9 +1286,9 @@ static PgHdr *pager_get_all_dirty_pages(Pager *pPager){
 }
 
 /*
-** Actquire a page.
+** Acquire a page.
 **
-** A read lock on the disk file is obtained when the first page is actquired. 
+** A read lock on the disk file is obtained when the first page is acquired. 
 ** This read lock is dropped when the last page is released.
 **
 ** A _get works for any page number greater than 0.  If the database
@@ -1297,13 +1297,13 @@ static PgHdr *pager_get_all_dirty_pages(Pager *pPager){
 ** all zeros.  The extra data appended to a page is always initialized
 ** to zeros the first time a page is loaded into memory.
 **
-** The actquisition might fail for several reasons.  In all cases,
+** The acquisition might fail for several reasons.  In all cases,
 ** an appropriate error code is returned and *ppPage is set to NULL.
 **
 ** See also sqlitepager_lookup().  Both this routine and _lookup() attempt
 ** to find a page in the in-memory cache first.  If the page is not already
 ** in memory, this routine goes to disk to read it in whereas _lookup()
-** just returns 0.  This routine actquires a read-lock the first time it
+** just returns 0.  This routine acquires a read-lock the first time it
 ** has to go to disk, and could also playback an old journal if necessary.
 ** Since _lookup() never goes to disk, it never has to deal with locks
 ** or journal files.
@@ -1366,7 +1366,7 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
        pPager->journalStarted = 0;
 
        /* Playback and delete the journal.  Drop the database write
-       ** lock and reactquire the read lock.
+       ** lock and reacquire the read lock.
        */
        rc = pager_playback(pPager, 0);
        if( rc!=SQLITE_OK ){
@@ -1544,7 +1544,7 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){
 }
 
 /*
-** Actquire a page if it is already in the in-memory cache.  Do
+** Acquire a page if it is already in the in-memory cache.  Do
 ** not read the page from disk.  Return a pointer to the page,
 ** or 0 if the page is not in cache.
 **
@@ -1692,7 +1692,7 @@ static int pager_open_journal(Pager *pPager){
 }
 
 /*
-** Actquire a write-lock on the database.  The lock is removed when
+** Acquire a write-lock on the database.  The lock is removed when
 ** the any of the following happen:
 **
 **   *  sqlitepager_commit() is called.
@@ -1702,7 +1702,7 @@ static int pager_open_journal(Pager *pPager){
 **
 ** The parameter to this routine is a pointer to any open page of the
 ** database file.  Nothing changes about the page - it is used merely
-** to actquire a pointer to the Pager structure and as proof that there
+** to acquire a pointer to the Pager structure and as proof that there
 ** is already a read-lock on the database.
 **
 ** A journal file is opened if this is not a temporary file.  For
@@ -1739,8 +1739,8 @@ int sqlitepager_begin(void *pData){
 ** changes to a page.
 **
 ** The first time this routine is called, the pager creates a new
-** journal and actquires a write lock on the database.  If the write
-** lock could not be actquired, this routine returns SQLITE_BUSY.  The
+** journal and acquires a write lock on the database.  If the write
+** lock could not be acquired, this routine returns SQLITE_BUSY.  The
 ** calling routine must check for that return value and be careful not to
 ** change any page data until this routine returns SQLITE_OK.
 **
diff --git a/src/3rdparty/sqlite/parse.c b/src/3rdparty/sqlite/parse.c
index 2fd6ae395..463536915 100644
--- a/src/3rdparty/sqlite/parse.c
+++ b/src/3rdparty/sqlite/parse.c
@@ -711,7 +711,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*      FLOAT => nothing */
     0,  /*       NULL => nothing */
     0,  /*    PRIMARY => nothing */
-    0,  /*     UNITQUE => nothing */
+    0,  /*     UNIQUE => nothing */
     0,  /*      CHECK => nothing */
     0,  /* REFERENCES => nothing */
     0,  /*    COLLATE => nothing */
@@ -840,7 +840,7 @@ static const char *yyTokenName[] = {
   "STAR",          "SLASH",         "REM",           "CONCAT",      
   "UMINUS",        "UPLUS",         "BITNOT",        "STRING",      
   "JOIN_KW",       "INTEGER",       "CONSTRAINT",    "DEFAULT",     
-  "FLOAT",         "NULL",          "PRIMARY",       "UNITQUE",      
+  "FLOAT",         "NULL",          "PRIMARY",       "UNIQUE",      
   "CHECK",         "REFERENCES",    "COLLATE",       "ON",          
   "DELETE",        "UPDATE",        "INSERT",        "SET",         
   "DEFERRABLE",    "FOREIGN",       "DROP",          "UNION",       
@@ -935,7 +935,7 @@ static const char *yyRuleName[] = {
  /*  53 */ "ccons ::= NULL onconf",
  /*  54 */ "ccons ::= NOT NULL onconf",
  /*  55 */ "ccons ::= PRIMARY KEY sortorder onconf",
- /*  56 */ "ccons ::= UNITQUE onconf",
+ /*  56 */ "ccons ::= UNIQUE onconf",
  /*  57 */ "ccons ::= CHECK LP expr RP onconf",
  /*  58 */ "ccons ::= REFERENCES nm idxlist_opt refargs",
  /*  59 */ "ccons ::= defer_subclause",
@@ -962,7 +962,7 @@ static const char *yyRuleName[] = {
  /*  80 */ "conslist ::= tcons",
  /*  81 */ "tcons ::= CONSTRAINT nm",
  /*  82 */ "tcons ::= PRIMARY KEY LP idxlist RP onconf",
- /*  83 */ "tcons ::= UNITQUE LP idxlist RP onconf",
+ /*  83 */ "tcons ::= UNIQUE LP idxlist RP onconf",
  /*  84 */ "tcons ::= CHECK expr onconf",
  /*  85 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt",
  /*  86 */ "defer_subclause_opt ::=",
@@ -1115,7 +1115,7 @@ static const char *yyRuleName[] = {
  /* 233 */ "expritem ::= expr",
  /* 234 */ "expritem ::=",
  /* 235 */ "cmd ::= CREATE uniqueflag INDEX nm ON nm dbnm LP idxlist RP onconf",
- /* 236 */ "uniqueflag ::= UNITQUE",
+ /* 236 */ "uniqueflag ::= UNIQUE",
  /* 237 */ "uniqueflag ::=",
  /* 238 */ "idxlist_opt ::=",
  /* 239 */ "idxlist_opt ::= LP idxlist RP",
@@ -2183,7 +2183,7 @@ static void yy_reduce(
 #line 191 "parse.y"
 {sqliteCreateIndex(pParse,0,0,0,yymsp[0].minor.yy372,0,0);}
 #line 2185 "parse.c"
-        /* No destructor defined for UNITQUE */
+        /* No destructor defined for UNIQUE */
         break;
       case 57:
         /* No destructor defined for CHECK */
@@ -2342,7 +2342,7 @@ static void yy_reduce(
 #line 238 "parse.y"
 {sqliteCreateIndex(pParse,0,0,yymsp[-2].minor.yy320,yymsp[0].minor.yy372,0,0);}
 #line 2344 "parse.c"
-        /* No destructor defined for UNITQUE */
+        /* No destructor defined for UNIQUE */
         /* No destructor defined for LP */
         /* No destructor defined for RP */
         break;
@@ -3428,7 +3428,7 @@ static void yy_reduce(
 #line 740 "parse.y"
 { yygotominor.yy372 = OE_Abort; }
 #line 3430 "parse.c"
-        /* No destructor defined for UNITQUE */
+        /* No destructor defined for UNIQUE */
         break;
       case 237:
 #line 741 "parse.y"
diff --git a/src/3rdparty/sqlite/parse.h b/src/3rdparty/sqlite/parse.h
index 35949283f..188a336c8 100644
--- a/src/3rdparty/sqlite/parse.h
+++ b/src/3rdparty/sqlite/parse.h
@@ -92,7 +92,7 @@
 #define TK_FLOAT                          92
 #define TK_NULL                           93
 #define TK_PRIMARY                        94
-#define TK_UNITQUE                         95
+#define TK_UNIQUE                         95
 #define TK_CHECK                          96
 #define TK_REFERENCES                     97
 #define TK_COLLATE                        98
diff --git a/src/3rdparty/sqlite/sqliteInt.h b/src/3rdparty/sqlite/sqliteInt.h
index 6fa4af400..4c2b64340 100644
--- a/src/3rdparty/sqlite/sqliteInt.h
+++ b/src/3rdparty/sqlite/sqliteInt.h
@@ -45,16 +45,16 @@
 /*
 ** If the following macro is set to 1, then NULL values are considered
 ** distinct when determining whether or not two entries are the same
-** in a UNITQUE index.  This is the way PostgreSQL, Oracle, DB2, MySQL,
+** in a UNIQUE index.  This is the way PostgreSQL, Oracle, DB2, MySQL,
 ** OCELOT, and Firebird all work.  The SQL92 spec explicitly says this
 ** is the way things are suppose to work.
 **
 ** If the following macro is set to 0, the NULLs are indistinct for
-** a UNITQUE index.  In this mode, you can only have a single NULL entry
-** for a column declared UNITQUE.  This is the way Informix and SQL Server
+** a UNIQUE index.  In this mode, you can only have a single NULL entry
+** for a column declared UNIQUE.  This is the way Informix and SQL Server
 ** work.
 */
-#define NULL_DISTINCT_FOR_UNITQUE 1
+#define NULL_DISTINCT_FOR_UNIQUE 1
 
 /*
 ** The maximum number of attached databases.  This must be at least 2
@@ -559,7 +559,7 @@ struct FKey {
 ** occurs.  IGNORE means that the particular row that caused the constraint
 ** error is not inserted or updated.  Processing continues and no error
 ** is returned.  REPLACE means that preexisting database rows that caused
-** a UNITQUE constraint violation are removed so that the new insert or
+** a UNIQUE constraint violation are removed so that the new insert or
 ** update can proceed.  Processing continues and no error is reported.
 **
 ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
@@ -619,7 +619,7 @@ struct Index {
   Table *pTable;   /* The SQL table being indexed */
   int tnum;        /* Page containing root of this index in database file */
   u8 onError;      /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
-  u8 autoIndex;    /* True if is automatically created (ex: by UNITQUE) */
+  u8 autoIndex;    /* True if is automatically created (ex: by UNIQUE) */
   u8 iDb;          /* Index in sqlite.aDb[] of where this index is stored */
   Index *pNext;    /* The next index associated with the same table */
 };
diff --git a/src/3rdparty/sqlite/tokenize.c b/src/3rdparty/sqlite/tokenize.c
index 96dad9f41..d0a34fed2 100644
--- a/src/3rdparty/sqlite/tokenize.c
+++ b/src/3rdparty/sqlite/tokenize.c
@@ -130,7 +130,7 @@ static Keyword aKeywordTable[] = {
   { "TRANSACTION",       TK_TRANSACTION,  },
   { "TRIGGER",           TK_TRIGGER,      },
   { "UNION",             TK_UNION,        },
-  { "UNITQUE",            TK_UNITQUE,       },
+  { "UNIQUE",            TK_UNIQUE,       },
   { "UPDATE",            TK_UPDATE,       },
   { "USING",             TK_USING,        },
   { "VACUUM",            TK_VACUUM,       },
diff --git a/src/3rdparty/sqlite/util.c b/src/3rdparty/sqlite/util.c
index 074afedf9..16b3b46a0 100644
--- a/src/3rdparty/sqlite/util.c
+++ b/src/3rdparty/sqlite/util.c
@@ -933,7 +933,7 @@ static int sqlite_utf8_to_int(const unsigned char *z){
 ** "[a-z]" matches any single lower-case letter.  To match a '-', make
 ** it the last character in the list.
 **
-** This routine is usually tquick, but can be N**2 in the worst case.
+** This routine is usually quick, but can be N**2 in the worst case.
 **
 ** Hints: to match '*' or '?', put them in "[]".  Like this:
 **
diff --git a/src/3rdparty/sqlite/vdbe.c b/src/3rdparty/sqlite/vdbe.c
index 3f0965a93..0d3fb43e6 100644
--- a/src/3rdparty/sqlite/vdbe.c
+++ b/src/3rdparty/sqlite/vdbe.c
@@ -2348,7 +2348,7 @@ case OP_VerifyCookie: {
 **
 ** There will be a read lock on the database whenever there is an
 ** open cursor.  If the database was unlocked prior to this instruction
-** then a read lock is actquired as part of this instruction.  A read
+** then a read lock is acquired as part of this instruction.  A read
 ** lock allows other processes to read the database but prohibits
 ** any other process from modifying the database.  The read lock is
 ** released when all cursors are closed.  If this instruction attempts
@@ -2741,7 +2741,7 @@ case OP_IsUnique: {
     /* The last four bytes of the key are different from R.  Convert the
     ** last four bytes of the key into an integer and push it onto the
     ** stack.  (These bytes are the record number of an entry that
-    ** violates a UNITQUE constraint.)
+    ** violates a UNIQUE constraint.)
     */
     pTos++;
     pTos->i = v;
diff --git a/src/3rdparty/sqlite/vdbeInt.h b/src/3rdparty/sqlite/vdbeInt.h
index c5ac74950..79b6b51a5 100644
--- a/src/3rdparty/sqlite/vdbeInt.h
+++ b/src/3rdparty/sqlite/vdbeInt.h
@@ -182,7 +182,7 @@ struct AggElem {
 };
 
 /*
-** A Set structure is used for tquick testing to see if a value
+** A Set structure is used for quick testing to see if a value
 ** is part of a small set.  Sets are used to implement code like
 ** this:
 **            x.y IN ('hi','hoo','hum')
diff --git a/src/3rdparty/sqlite/where.c b/src/3rdparty/sqlite/where.c
index ea713c336..34195c651 100644
--- a/src/3rdparty/sqlite/where.c
+++ b/src/3rdparty/sqlite/where.c
@@ -412,7 +412,7 @@ WhereInfo *sqliteWhereBegin(
     exprAnalyze(&maskSet, &aExpr[i]);
 
     /* If we are executing a trigger body, remove all references to
-    ** new.* and old.* tables from the preretquisite masks.
+    ** new.* and old.* tables from the prerequisite masks.
     */
     if( pParse->trigStack ){
       int x;