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

Changes to sqlite3/src/main/jni/sqlite/sqlite3.c.

     1      1   /******************************************************************************
     2      2   ** This file is an amalgamation of many separate C source files from SQLite
     3         -** version 3.25.2.  By combining all the individual C code files into this
            3  +** version 3.25.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
................................................................................
   950    950   ** you should probably leave LFS enabled.  But some embedded platforms might
   951    951   ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
   952    952   **
   953    953   ** Similar is true for Mac OS X.  LFS is only supported on Mac OS X 9 and later.
   954    954   */
   955    955   #ifndef SQLITE_DISABLE_LFS
   956    956   # define _LARGE_FILE       1
   957         -#if 0
   958    957   # ifndef _FILE_OFFSET_BITS
   959    958   #   define _FILE_OFFSET_BITS 64
   960    959   # endif
   961         -#endif
   962    960   # define _LARGEFILE_SOURCE 1
   963    961   #endif
   964    962   
   965    963   /* The GCC_VERSION and MSVC_VERSION macros are used to
   966    964   ** conditionally include optimizations for each of these compilers.  A
   967    965   ** value of 0 means that compiler is not being used.  The
   968    966   ** SQLITE_DISABLE_INTRINSIC macro means do not use any compiler-specific
................................................................................
  1154   1152   ** been edited in any way since it was last checked in, then the last
  1155   1153   ** four hexadecimal digits of the hash may be modified.
  1156   1154   **
  1157   1155   ** See also: [sqlite3_libversion()],
  1158   1156   ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
  1159   1157   ** [sqlite_version()] and [sqlite_source_id()].
  1160   1158   */
  1161         -#define SQLITE_VERSION        "3.25.2"
  1162         -#define SQLITE_VERSION_NUMBER 3025002
  1163         -#define SQLITE_SOURCE_ID      "2018-09-25 19:08:10 fb90e7189ae6d62e77ba3a308ca5d683f90bbe633cf681865365b8e92792d1c7"
         1159  +#define SQLITE_VERSION        "3.25.3"
         1160  +#define SQLITE_VERSION_NUMBER 3025003
         1161  +#define SQLITE_SOURCE_ID      "2018-11-05 20:37:38 89e099fbe5e13c33e683bef07361231ca525b88f7907be7092058007b75036f2"
  1164   1162   
  1165   1163   /*
  1166   1164   ** CAPI3REF: Run-Time Library Version Numbers
  1167   1165   ** KEYWORDS: sqlite3_version sqlite3_sourceid
  1168   1166   **
  1169   1167   ** These interfaces provide the same information as the [SQLITE_VERSION],
  1170   1168   ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
 17910  17908   **    OPFLAG_SEEKEQ       == BTREE_SEEK_EQ
 17911  17909   **    OPFLAG_FORDELETE    == BTREE_FORDELETE
 17912  17910   **    OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION
 17913  17911   **    OPFLAG_AUXDELETE    == BTREE_AUXDELETE
 17914  17912   */
 17915  17913   #define OPFLAG_NCHANGE       0x01    /* OP_Insert: Set to update db->nChange */
 17916  17914                                        /* Also used in P2 (not P5) of OP_Delete */
        17915  +#define OPFLAG_NOCHNG        0x01    /* OP_VColumn nochange for UPDATE */
 17917  17916   #define OPFLAG_EPHEM         0x01    /* OP_Column: Ephemeral output is ok */
 17918  17917   #define OPFLAG_LASTROWID     0x20    /* Set to update db->lastRowid */
 17919  17918   #define OPFLAG_ISUPDATE      0x04    /* This OP_Insert is an sql UPDATE */
 17920  17919   #define OPFLAG_APPEND        0x08    /* This is likely to be an append */
 17921  17920   #define OPFLAG_USESEEKRESULT 0x10    /* Try to avoid a seek in BtreeInsert() */
 17922  17921   #define OPFLAG_ISNOOP        0x40    /* OP_Delete does pre-update-hook only */
 17923  17922   #define OPFLAG_LENGTHARG     0x40    /* OP_Column only used for length() */
................................................................................
 80101  80100       return rc;
 80102  80101     }
 80103  80102   
 80104  80103     /* The index entry must begin with a header size */
 80105  80104     (void)getVarint32((u8*)m.z, szHdr);
 80106  80105     testcase( szHdr==3 );
 80107  80106     testcase( szHdr==m.n );
 80108         -  if( unlikely(szHdr<3 || (int)szHdr>m.n) ){
        80107  +  testcase( szHdr>0x7fffffff );
        80108  +  assert( m.n>=0 );
        80109  +  if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){
 80109  80110       goto idx_rowid_corruption;
 80110  80111     }
 80111  80112   
 80112  80113     /* The last field of the index should be an integer - the ROWID.
 80113  80114     ** Verify that the last entry really is an integer. */
 80114  80115     (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
 80115  80116     testcase( typeRowid==1 );
................................................................................
 89614  89615   ** Synopsis: r[P3]=vcolumn(P2)
 89615  89616   **
 89616  89617   ** Store in register P3 the value of the P2-th column of
 89617  89618   ** the current row of the virtual-table of cursor P1.
 89618  89619   **
 89619  89620   ** If the VColumn opcode is being used to fetch the value of
 89620  89621   ** an unchanging column during an UPDATE operation, then the P5
 89621         -** value is 1.  Otherwise, P5 is 0.  The P5 value is returned
 89622         -** by sqlite3_vtab_nochange() routine and can be used
 89623         -** by virtual table implementations to return special "no-change"
 89624         -** marks which can be more efficient, depending on the virtual table.
        89622  +** value is OPFLAG_NOCHNG.  This will cause the sqlite3_vtab_nochange()
        89623  +** function to return true inside the xColumn method of the virtual
        89624  +** table implementation.  The P5 column might also contain other
        89625  +** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are
        89626  +** unused by OP_VColumn.
 89625  89627   */
 89626  89628   case OP_VColumn: {
 89627  89629     sqlite3_vtab *pVtab;
 89628  89630     const sqlite3_module *pModule;
 89629  89631     Mem *pDest;
 89630  89632     sqlite3_context sContext;
 89631  89633   
................................................................................
 89639  89641       break;
 89640  89642     }
 89641  89643     pVtab = pCur->uc.pVCur->pVtab;
 89642  89644     pModule = pVtab->pModule;
 89643  89645     assert( pModule->xColumn );
 89644  89646     memset(&sContext, 0, sizeof(sContext));
 89645  89647     sContext.pOut = pDest;
 89646         -  if( pOp->p5 ){
        89648  +  testcase( (pOp->p5 & OPFLAG_NOCHNG)==0 && pOp->p5!=0 );
        89649  +  if( pOp->p5 & OPFLAG_NOCHNG ){
 89647  89650       sqlite3VdbeMemSetNull(pDest);
 89648  89651       pDest->flags = MEM_Null|MEM_Zero;
 89649  89652       pDest->u.nZero = 0;
 89650  89653     }else{
 89651  89654       MemSetTypeFlag(pDest, MEM_Null);
 89652  89655     }
 89653  89656     rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
................................................................................
125438 125441     int eDest = SRT_Fifo;         /* How to write to Queue */
125439 125442     SelectDest destQueue;         /* SelectDest targetting the Queue table */
125440 125443     int i;                        /* Loop counter */
125441 125444     int rc;                       /* Result code */
125442 125445     ExprList *pOrderBy;           /* The ORDER BY clause */
125443 125446     Expr *pLimit;                 /* Saved LIMIT and OFFSET */
125444 125447     int regLimit, regOffset;      /* Registers used by LIMIT and OFFSET */
       125448  +
       125449  +#ifndef SQLITE_OMIT_WINDOWFUNC
       125450  +  if( p->pWin ){
       125451  +    sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries");
       125452  +    return;
       125453  +  }
       125454  +#endif
125445 125455   
125446 125456     /* Obtain authorization to do a recursive query */
125447 125457     if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
125448 125458   
125449 125459     /* Process the LIMIT and OFFSET clauses, if they exist */
125450 125460     addrBreak = sqlite3VdbeMakeLabel(v);
125451 125461     p->nSelectRow = 320;  /* 4 billion rows */
................................................................................
127188 127198   #endif
127189 127199   
127190 127200     return 1;
127191 127201   }
127192 127202   #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
127193 127203   
127194 127204   /*
127195         -** A structure to keep track of all of the column values that fixed to
       127205  +** A structure to keep track of all of the column values that are fixed to
127196 127206   ** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
127197 127207   */
127198 127208   typedef struct WhereConst WhereConst;
127199 127209   struct WhereConst {
127200 127210     Parse *pParse;   /* Parsing context */
127201 127211     int nConst;      /* Number for COLUMN=CONSTANT terms */
127202 127212     int nChng;       /* Number of times a constant is propagated */
127203 127213     Expr **apExpr;   /* [i*2] is COLUMN and [i*2+1] is VALUE */
127204 127214   };
127205 127215   
127206 127216   /*
127207         -** Add a new entry to the pConst object
       127217  +** Add a new entry to the pConst object.  Except, do not add duplicate
       127218  +** pColumn entires.
127208 127219   */
127209 127220   static void constInsert(
127210         -  WhereConst *pConst,
127211         -  Expr *pColumn,
127212         -  Expr *pValue
       127221  +  WhereConst *pConst,      /* The WhereConst into which we are inserting */
       127222  +  Expr *pColumn,           /* The COLUMN part of the constraint */
       127223  +  Expr *pValue             /* The VALUE part of the constraint */
127213 127224   ){
       127225  +  int i;
       127226  +  assert( pColumn->op==TK_COLUMN );
       127227  +
       127228  +  /* 2018-10-25 ticket [cf5ed20f]
       127229  +  ** Make sure the same pColumn is not inserted more than once */
       127230  +  for(i=0; i<pConst->nConst; i++){
       127231  +    const Expr *pExpr = pConst->apExpr[i*2];
       127232  +    assert( pExpr->op==TK_COLUMN );
       127233  +    if( pExpr->iTable==pColumn->iTable
       127234  +     && pExpr->iColumn==pColumn->iColumn
       127235  +    ){
       127236  +      return;  /* Already present.  Return without doing anything. */
       127237  +    }
       127238  +  }
127214 127239   
127215 127240     pConst->nConst++;
127216 127241     pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
127217 127242                            pConst->nConst*2*sizeof(Expr*));
127218 127243     if( pConst->apExpr==0 ){
127219 127244       pConst->nConst = 0;
127220 127245     }else{
................................................................................
131972 131997   
131973 131998     /* Populate the argument registers. */
131974 131999     for(i=0; i<pTab->nCol; i++){
131975 132000       if( aXRef[i]>=0 ){
131976 132001         sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
131977 132002       }else{
131978 132003         sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
131979         -      sqlite3VdbeChangeP5(v, 1); /* Enable sqlite3_vtab_nochange() */
       132004  +      sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* Enable sqlite3_vtab_nochange() */
131980 132005       }
131981 132006     }
131982 132007     if( HasRowid(pTab) ){
131983 132008       sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
131984 132009       if( pRowid ){
131985 132010         sqlite3ExprCode(pParse, pRowid, regArg+1);
131986 132011       }else{
................................................................................
134927 134952       ExprList *pLhs = 0;         /* New LHS after mods */
134928 134953       int i;                      /* Loop counter */
134929 134954       Select *pSelect;            /* Pointer to the SELECT on the RHS */
134930 134955   
134931 134956       for(i=iEq; i<pLoop->nLTerm; i++){
134932 134957         if( pLoop->aLTerm[i]->pExpr==pX ){
134933 134958           int iField = pLoop->aLTerm[i]->iField - 1;
134934         -        assert( pOrigRhs->a[iField].pExpr!=0 );
       134959  +        if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
134935 134960           pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
134936 134961           pOrigRhs->a[iField].pExpr = 0;
134937 134962           assert( pOrigLhs->a[iField].pExpr!=0 );
134938 134963           pLhs = sqlite3ExprListAppend(pParse, pLhs, pOrigLhs->a[iField].pExpr);
134939 134964           pOrigLhs->a[iField].pExpr = 0;
134940 134965         }
134941 134966       }
................................................................................
138120 138145     ** virtual term of that form.
138121 138146     **
138122 138147     ** Note that the virtual term must be tagged with TERM_VNULL.
138123 138148     */
138124 138149     if( pExpr->op==TK_NOTNULL
138125 138150      && pExpr->pLeft->op==TK_COLUMN
138126 138151      && pExpr->pLeft->iColumn>=0
       138152  +   && !ExprHasProperty(pExpr, EP_FromJoin)
138127 138153      && OptimizationEnabled(db, SQLITE_Stat34)
138128 138154     ){
138129 138155       Expr *pNewExpr;
138130 138156       Expr *pLeft = pExpr->pLeft;
138131 138157       int idxNew;
138132 138158       WhereTerm *pNewTerm;
138133 138159   
................................................................................
159159 159185     sqlite3_int64 *piFirst,         /* OUT: Selected child node */
159160 159186     sqlite3_int64 *piLast           /* OUT: Selected child node */
159161 159187   ){
159162 159188     int rc = SQLITE_OK;             /* Return code */
159163 159189     const char *zCsr = zNode;       /* Cursor to iterate through node */
159164 159190     const char *zEnd = &zCsr[nNode];/* End of interior node buffer */
159165 159191     char *zBuffer = 0;              /* Buffer to load terms into */
159166         -  int nAlloc = 0;                 /* Size of allocated buffer */
       159192  +  i64 nAlloc = 0;                 /* Size of allocated buffer */
159167 159193     int isFirstTerm = 1;            /* True when processing first term on page */
159168 159194     sqlite3_int64 iChild;           /* Block id of child node to descend to */
159169 159195   
159170 159196     /* Skip over the 'height' varint that occurs at the start of every 
159171 159197     ** interior node. Then load the blockid of the left-child of the b-tree
159172 159198     ** node into variable iChild.  
159173 159199     **
................................................................................
159197 159223       if( !isFirstTerm ){
159198 159224         zCsr += fts3GetVarint32(zCsr, &nPrefix);
159199 159225       }
159200 159226       isFirstTerm = 0;
159201 159227       zCsr += fts3GetVarint32(zCsr, &nSuffix);
159202 159228       
159203 159229       assert( nPrefix>=0 && nSuffix>=0 );
159204         -    if( &zCsr[nSuffix]>zEnd ){
       159230  +    if( nPrefix>zCsr-zNode || nSuffix>zEnd-zCsr ){
159205 159231         rc = FTS_CORRUPT_VTAB;
159206 159232         goto finish_scan;
159207 159233       }
159208         -    if( nPrefix+nSuffix>nAlloc ){
       159234  +    if( (i64)nPrefix+nSuffix>nAlloc ){
159209 159235         char *zNew;
159210         -      nAlloc = (nPrefix+nSuffix) * 2;
159211         -      zNew = (char *)sqlite3_realloc(zBuffer, nAlloc);
       159236  +      nAlloc = ((i64)nPrefix+nSuffix) * 2;
       159237  +      zNew = (char *)sqlite3_realloc64(zBuffer, nAlloc);
159212 159238         if( !zNew ){
159213 159239           rc = SQLITE_NOMEM;
159214 159240           goto finish_scan;
159215 159241         }
159216 159242         zBuffer = zNew;
159217 159243       }
159218 159244       assert( zBuffer );
................................................................................
168786 168812     rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2);
168787 168813     if( rc!=SQLITE_OK ) return rc;
168788 168814     
168789 168815     /* Because of the FTS3_NODE_PADDING bytes of padding, the following is 
168790 168816     ** safe (no risk of overread) even if the node data is corrupted. */
168791 168817     pNext += fts3GetVarint32(pNext, &nPrefix);
168792 168818     pNext += fts3GetVarint32(pNext, &nSuffix);
168793         -  if( nPrefix<0 || nSuffix<=0 
168794         -   || &pNext[nSuffix]>&pReader->aNode[pReader->nNode] 
       168819  +  if( nSuffix<=0 
       168820  +   || (&pReader->aNode[pReader->nNode] - pNext)<nSuffix
       168821  +   || nPrefix>pReader->nTermAlloc
168795 168822     ){
168796 168823       return FTS_CORRUPT_VTAB;
168797 168824     }
168798 168825   
168799         -  if( nPrefix+nSuffix>pReader->nTermAlloc ){
168800         -    int nNew = (nPrefix+nSuffix)*2;
168801         -    char *zNew = sqlite3_realloc(pReader->zTerm, nNew);
       168826  +  /* Both nPrefix and nSuffix were read by fts3GetVarint32() and so are
       168827  +  ** between 0 and 0x7FFFFFFF. But the sum of the two may cause integer
       168828  +  ** overflow - hence the (i64) casts.  */
       168829  +  if( (i64)nPrefix+nSuffix>(i64)pReader->nTermAlloc ){
       168830  +    i64 nNew = ((i64)nPrefix+nSuffix)*2;
       168831  +    char *zNew = sqlite3_realloc64(pReader->zTerm, nNew);
168802 168832       if( !zNew ){
168803 168833         return SQLITE_NOMEM;
168804 168834       }
168805 168835       pReader->zTerm = zNew;
168806 168836       pReader->nTermAlloc = nNew;
168807 168837     }
168808 168838   
................................................................................
168816 168846     pReader->aDoclist = pNext;
168817 168847     pReader->pOffsetList = 0;
168818 168848   
168819 168849     /* Check that the doclist does not appear to extend past the end of the
168820 168850     ** b-tree node. And that the final byte of the doclist is 0x00. If either 
168821 168851     ** of these statements is untrue, then the data structure is corrupt.
168822 168852     */
168823         -  if( &pReader->aDoclist[pReader->nDoclist]>&pReader->aNode[pReader->nNode] 
       168853  +  if( (&pReader->aNode[pReader->nNode] - pReader->aDoclist)<pReader->nDoclist
168824 168854      || (pReader->nPopulate==0 && pReader->aDoclist[pReader->nDoclist-1])
168825 168855     ){
168826 168856       return FTS_CORRUPT_VTAB;
168827 168857     }
168828 168858     return SQLITE_OK;
168829 168859   }
168830 168860   
................................................................................
171142 171172       p->aNode = 0;
171143 171173     }else{
171144 171174       if( bFirst==0 ){
171145 171175         p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nPrefix);
171146 171176       }
171147 171177       p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nSuffix);
171148 171178   
       171179  +    if( nPrefix>p->iOff || nSuffix>p->nNode-p->iOff ){
       171180  +      return SQLITE_CORRUPT_VTAB;
       171181  +    }
171149 171182       blobGrowBuffer(&p->term, nPrefix+nSuffix, &rc);
171150 171183       if( rc==SQLITE_OK ){
171151 171184         memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix);
171152 171185         p->term.n = nPrefix+nSuffix;
171153 171186         p->iOff += nSuffix;
171154 171187         if( p->iChild==0 ){
171155 171188           p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &p->nDoclist);
       171189  +        if( (p->nNode-p->iOff)<p->nDoclist ){
       171190  +          return SQLITE_CORRUPT_VTAB;
       171191  +        }
171156 171192           p->aDoclist = &p->aNode[p->iOff];
171157 171193           p->iOff += p->nDoclist;
171158 171194         }
171159 171195       }
171160 171196     }
171161 171197   
171162 171198     assert( p->iOff<=p->nNode );
171163         -
171164 171199     return rc;
171165 171200   }
171166 171201   
171167 171202   /*
171168 171203   ** Release all dynamic resources held by node-reader object *p.
171169 171204   */
171170 171205   static void nodeReaderRelease(NodeReader *p){
................................................................................
214442 214477   static void fts5SourceIdFunc(
214443 214478     sqlite3_context *pCtx,          /* Function call context */
214444 214479     int nArg,                       /* Number of args */
214445 214480     sqlite3_value **apUnused        /* Function arguments */
214446 214481   ){
214447 214482     assert( nArg==0 );
214448 214483     UNUSED_PARAM2(nArg, apUnused);
214449         -  sqlite3_result_text(pCtx, "fts5: 2018-09-25 19:08:10 fb90e7189ae6d62e77ba3a308ca5d683f90bbe633cf681865365b8e92792d1c7", -1, SQLITE_TRANSIENT);
       214484  +  sqlite3_result_text(pCtx, "fts5: 2018-11-05 20:37:38 89e099fbe5e13c33e683bef07361231ca525b88f7907be7092058007b75036f2", -1, SQLITE_TRANSIENT);
214450 214485   }
214451 214486   
214452 214487   static int fts5Init(sqlite3 *db){
214453 214488     static const sqlite3_module fts5Mod = {
214454 214489       /* iVersion      */ 2,
214455 214490       /* xCreate       */ fts5CreateMethod,
214456 214491       /* xConnect      */ fts5ConnectMethod,
................................................................................
219152 219187   #endif
219153 219188     return rc;
219154 219189   }
219155 219190   #endif /* SQLITE_CORE */
219156 219191   #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */
219157 219192   
219158 219193   /************** End of stmt.c ************************************************/
219159         -#if __LINE__!=219157
       219194  +#if __LINE__!=219194
219160 219195   #undef SQLITE_SOURCE_ID
219161         -#define SQLITE_SOURCE_ID      "2018-09-25 19:08:10 fb90e7189ae6d62e77ba3a308ca5d683f90bbe633cf681865365b8e92792alt2"
       219196  +#define SQLITE_SOURCE_ID      "2018-11-05 20:37:38 89e099fbe5e13c33e683bef07361231ca525b88f7907be7092058007b750alt2"
219162 219197   #endif
219163 219198   /* Return the source-id for this library */
219164 219199   SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
219165 219200   /************************** End of sqlite3.c ******************************/

Changes to sqlite3/src/main/jni/sqlite/sqlite3.h.

   119    119   ** been edited in any way since it was last checked in, then the last
   120    120   ** four hexadecimal digits of the hash may be modified.
   121    121   **
   122    122   ** See also: [sqlite3_libversion()],
   123    123   ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
   124    124   ** [sqlite_version()] and [sqlite_source_id()].
   125    125   */
   126         -#define SQLITE_VERSION        "3.25.2"
   127         -#define SQLITE_VERSION_NUMBER 3025002
   128         -#define SQLITE_SOURCE_ID      "2018-09-25 19:08:10 fb90e7189ae6d62e77ba3a308ca5d683f90bbe633cf681865365b8e92792d1c7"
          126  +#define SQLITE_VERSION        "3.25.3"
          127  +#define SQLITE_VERSION_NUMBER 3025003
          128  +#define SQLITE_SOURCE_ID      "2018-11-05 20:37:38 89e099fbe5e13c33e683bef07361231ca525b88f7907be7092058007b75036f2"
   129    129   
   130    130   /*
   131    131   ** CAPI3REF: Run-Time Library Version Numbers
   132    132   ** KEYWORDS: sqlite3_version sqlite3_sourceid
   133    133   **
   134    134   ** These interfaces provide the same information as the [SQLITE_VERSION],
   135    135   ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros