contrib/sqlite3/sqlite3.c

10587   int *pRes
10600 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes);
10601 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes);
10602 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int *pRes);
10604 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int *pRes);
45050 ** that is read in *pRes.  Return SQLITE_OK if everything worked, or an
45055 static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
45059     *pRes = sqlite3Get4byte(ac);
56556   int *pRes           /* Write search results here */
56577   rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
60772 ** on success.  Set *pRes to 0 if the cursor actually points to something
60773 ** or set *pRes to 1 if the table is empty.
60775 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
60784       *pRes = 1;
60787       *pRes = 0;
60795 ** on success.  Set *pRes to 0 if the cursor actually points to something
60796 ** or set *pRes to 1 if the table is empty.
60798 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
60823       *pRes = 1;
60826       *pRes = 0;
60851 ** An integer is written into *pRes which is the result of
60854 ** *pRes is as follows:
60856 **     *pRes<0      The cursor is left pointing at an entry that
60860 **     *pRes==0     The cursor is left pointing at an entry that
60863 **     *pRes>0      The cursor is left pointing at an entry that
60874   int *pRes                /* Write search results here */
60881   assert( pRes );
60890       *pRes = 0;
60894       *pRes = -1;
60918     *pRes = -1;
60968             *pRes = 0;
61049           *pRes = 0;
61065       *pRes = c;
61103 ** successful then set *pRes=0.  If the cursor
61105 ** this routine was called, then set *pRes=1.
61113 ** The calling function will set *pRes to 0 or 1.  The initial *pRes value
61116 ** a unique index.  Otherwise the caller will have set *pRes to zero.
61118 ** initial *pRes value as a hint to improve performance, but the current
61122 static SQLITE_NOINLINE int btreeNext(BtCursor *pCur, int *pRes){
61129   assert( *pRes==0 );
61137       *pRes = 1;
61170         *pRes = 1;
61178       return sqlite3BtreeNext(pCur, pRes);
61189 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
61192   assert( pRes!=0 );
61193   assert( *pRes==0 || *pRes==1 );
61197   *pRes = 0;
61198   if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur, pRes);
61202     return btreeNext(pCur, pRes);
61213 ** successful then set *pRes=0.  If the cursor
61215 ** this routine was called, then set *pRes=1.
61223 ** The calling function will set *pRes to 0 or 1.  The initial *pRes value
61226 ** a unique index.  Otherwise the caller will have set *pRes to zero.
61228 ** initial *pRes value as a hint to improve performance, but the current
61232 static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur, int *pRes){
61237   assert( pRes!=0 );
61238   assert( *pRes==0 );
61248       *pRes = 1;
61273         *pRes = 1;
61284       rc = sqlite3BtreePrevious(pCur, pRes);
61291 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
61293   assert( pRes!=0 );
61294   assert( *pRes==0 || *pRes==1 );
61296   *pRes = 0;
61303     return btreePrevious(pCur, pRes);
72378 ** the key string in pUnpacked.  Write into *pRes a number
84535 ** Otherwise, set *pRes to a negative, zero or positive value if the
84546   int *pRes                       /* OUT: Result of comparison */
84571       *pRes = -1;
84576   *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2);
88239   Expr *pRes;
88264   pRes = pEList->a[0].pExpr;
88265   if( pRes->op!=TK_COLUMN ) return 0;    /* Result is a column */
88266   assert( pRes->iTable==pSrc->a[0].iCursor );  /* Not a correlated subquery */
101835   sqlite3_value *pRes;
101836   pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
101837   if( pRes ){
101838     if( pRes->flags ){
101839       sqlite3_result_value(context, pRes);
101841     sqlite3VdbeMemRelease(pRes);
134041           int *pRes = va_arg(ap, int*);
134051           if( pRes ){
134052             *pRes = (db->flags & aFlagOp[i].mask)!=0;
178870 ** in *pRes is the correct result of comparing the current positions of the
178877   Fts5CResult *pRes
178884       assert( pRes->iFirst==i2 );
178886       assert( pRes->iFirst==i1 );
178893         assert( pRes->bTermEq==1 );
178897         assert( pRes->bTermEq==0 );
178901         assert( pRes->iFirst==i1 );
178903         assert( pRes->iFirst==i2 );
178936       Fts5CResult *pRes = &pIter->aFirst[(pIter->nSeg + i) / 2];
178937       fts5AssertComparisonResult(pIter, p1, p2, pRes);
178943       Fts5CResult *pRes = &pIter->aFirst[i];
178944       fts5AssertComparisonResult(pIter, p1, p2, pRes);
178966   Fts5CResult *pRes = &pIter->aFirst[iOut];
178981   pRes->bTermEq = 0;
178991       pRes->bTermEq = 1;
179006   pRes->iFirst = (u16)iRes;
179160       Fts5CResult *pRes = &pIter->aFirst[i];
179163       assert( pRes->bTermEq==0 || pOther->pLeaf );
179165       if( pRes->bTermEq ){
179175       pRes->iFirst = (u16)(pNew - pIter->aSeg);