[sqlite] sql::Recovery working under USE_SYSTEM_SQLITE.

third_party/sqlite/src/src/recover.c

 /*
 ** 2012 Jan 11
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 */
@@ skipping 683 matching lines @@
 }
 
 /* Cursor for iterating interior nodes.  Interior page cells contain a
  * child page number and a rowid.  The child page contains items left
  * of the rowid (less than).  The rightmost page of the subtree is
  * stored in the page header.
  *
  * interiorCursorDestroy - release all resources associated with the
  *                         cursor and any parent cursors.
  * interiorCursorCreate - create a cursor with the given parent and page.
- * interiorCursorEOF - returns true if neither the cursor nor the
- *                     parent cursors can return any more data.
  * interiorCursorNextPage - fetch the next child page from the cursor.
  *
  * Logically, interiorCursorNextPage() returns the next child page
  * number from the page the cursor is currently reading, calling the
  * parent cursor as necessary to get new pages to read, until done.
  * SQLITE_ROW if a page is returned, SQLITE_DONE if out of pages,
  * error otherwise.  Unfortunately, if the table is corrupted
  * unexpected pages can be returned.  If any unexpected page is found,
  * leaf or otherwise, it is returned to the caller for processing,
  * with the interior cursor left empty.  The next call to
  * interiorCursorNextPage() will recurse to the parent cursor until an
  * interior page to iterate is returned.
  *
  * Note that while interiorCursorNextPage() will refuse to follow
  * loops, it does not keep track of pages returned for purposes of
  * preventing duplication.
- *
- * Note that interiorCursorEOF() could return false (not at EOF), and
- * interiorCursorNextPage() could still return SQLITE_DONE.  This
- * could happen if there are more cells to iterate in an interior
- * page, but those cells refer to invalid pages.
  */
 typedef struct RecoverInteriorCursor RecoverInteriorCursor;
 struct RecoverInteriorCursor {
   RecoverInteriorCursor *pParent; /* Parent node to this node. */
   RecoverPage *pPage;             /* Reference to leaf page. */
   unsigned nPageSize;             /* Size of page. */
   unsigned nChildren;             /* Number of children on the page. */
   unsigned iChild;                /* Index of next child to return. */
 };
 
@@ skipping 95 matching lines @@
 
   /* TODO(shess): Check for cell overlaps?  Cells require 4 bytes plus
    * a varint.  Check could be identical to leaf check (or even a
    * shared helper testing for "Cells starting in this range"?).
    */
 
   /* If the offset is broken, return an invalid page number. */
   return 0;
 }
 
-static int interiorCursorEOF(RecoverInteriorCursor *pCursor){
-  /* Find a parent with remaining children.  EOF if none found. */
-  while( pCursor && pCursor->iChild>=pCursor->nChildren ){
-    pCursor = pCursor->pParent;
-  }
-  return pCursor==NULL;
-}
-
 /* Internal helper.  Used to detect if iPage would cause a loop. */
 static int interiorCursorPageInUse(RecoverInteriorCursor *pCursor,
                                    unsigned iPage){
   /* Find any parent using the indicated page. */
   while( pCursor && pCursor->pPage->pgno!=iPage ){
     pCursor = pCursor->pParent;
   }
   return pCursor!=NULL;
 }
 
@@ skipping 1416 matching lines @@
   rc = sqlite3_declare_vtab(db, zCreateSql);
   sqlite3_free(zCreateSql);
   if( rc!=SQLITE_OK ){
     recoverRelease(pRecover);
     return rc;
   }
 
   *ppVtab = (sqlite3_vtab *)pRecover;
   return SQLITE_OK;
 }